Prove correlated dirt is necessary at P104 wire meetings (no κ)

research/p104-wire-dirty-entry/PROOF.md

@@ -0,0 +1,132 @@
+# Correlated dirt at a three-register wire meeting
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+## Boundary and claim type
+
+This is a scoped response-space proof and a finite local response construction.
+It partially answers Matarener's PR6217 one-helper wire question. It neither
+supplies nor excludes a complete one-helper program.
+
+We cite PR6217's premises, without replaying its proof or census. For an A2
+pair x,y the common seven-frame G has 24 retained ports. Its required rows
+are proportional except at the third vertex z, where their ratio changes
+sign. Every incoming six-frame contains at most 16 of these ports. The
+content-in-frame rule confines incoming live coefficients to those ports.
+
+The boundary has three incoming registers, one independent dirty scalar h,
+and no further live reads, allocation, erasure or incoming registers during
+the local meeting. Arbitrarily many rational linear local operations are
+allowed. Two outputs must have the prescribed live responses and zero h
+coefficient. Other initial public and helper columns are projected away.
+This projection is necessary for a full program; sufficiency is not claimed.
+
+## General kernel statement
+
+Let K have characteristic different from two. Let C contain m ports with
+distinguished z. Let e be a nonzero row supported only at z. Let c_z=0 and
+c_t be nonzero for every t different from z. Put W=span(c,e). Suppose the
+incoming registers are
+
+    R_i = A_i X + b_i h,   i=0,1,2,
+
+where b is nonzero, X has independent live coordinates, and each A_i has
+support strictly smaller than m-1. Suppose local linear processing produces
+c+e and c-e, both with zero h coefficient. Then:
+
+1. At least two entries of b are nonzero. An isolated dirty helper with two
+   h-free public inputs cannot suffice, regardless of the helper's live row.
+2. If exactly two entries of b are nonzero, the sole h-free live row is a
+   nonzero multiple of e. The dirty pair's live supports jointly cover all
+   m-1 nonexceptional ports. If each support has size at most s, each dirty
+   row contains at least m-1-s nonexceptional ports.
+
+These are necessary conditions. They do not characterize the case where all
+three inputs carry h. The support restriction is essential.
+
+*Proof.* Every eventual register is a linear combination of the incoming
+registers. Its h coefficient vanishes precisely when the combination lies
+in ker(b^T), of dimension two. The rows c+e and c-e are independent because
+2 is nonzero. Therefore the live-image map
+
+    L: ker(b^T) -> K^C,   lambda -> sum_i lambda_i A_i
+
+has image exactly W and is injective. If b_i=0, its coordinate vector lies
+in the kernel. Thus A_i belongs to W and is nonzero. Every alpha*c+beta*e
+with alpha nonzero has at least m-1 support positions, so such A_i must be
+a nonzero multiple of e. Two h-free rows would make L noninjective. This
+proves the first assertion.
+
+For the second, let i be the clean index and j,k the dirty indices. A kernel
+basis consists of the i-th coordinate vector and b_k times the j-th minus
+b_j times the k-th. Their live images A_i and b_k A_j-b_j A_k span W. The
+latter must have a nonzero c coefficient. At every t different from z,
+at least one of A_jt,A_kt is consequently nonzero. Their union covers m-1
+positions, giving each stated support lower bound. QED.
+
+The proof even permits arbitrary linear readouts, without invertibility.
+For PR6217, m=24 and s=16. Correlated dirt on at least two incoming rows is
+necessary. If exactly two carry dirt, the clean row must already isolate z,
+and each dirty row carries at least seven of the other 23 coordinates. This
+is a concrete entry condition, not a claim that it can be prepared cheaply.
+
+## Local response construction
+
+The correlated-dirt escape is nonempty. Use literal port labels
+x=11, y=19, z=487. Let G be the kernel of normals 11 and 19 in F2^9.
+Add respectively normals 455 and 56 for six-frames H_0,H_1. Both normal
+triples have rank three. Their port sections are complementary because
+455 XOR 56=511 and every port has odd weight. The sections have sizes 16
+and 8; z belongs to the former.
+
+In the canonical gauge take the required rows G_x/2 and G_y/2 on these
+24 ports. Here G_xy=1. Write these as c+e and c-e, where
+e=(G_xz/2)e_z. Put a=c restricted to H_0 and d=c restricted to H_1.
+Their support sizes are 15 and 8, and a+d=c. Supply
+
+    R_0=eX,   R_1=aX-h,   R_2=dX+h.
+
+Their live parts lie in the declared six-frames. Once they meet at G, use
+these four scalar events:
+
+    R_1 += R_2
+    R_1 -= R_0
+    R_0 *= 2
+    R_0 += R_1
+
+The exact endpoint is
+
+    R_0=(c+e)X,   R_1=(c-e)X,   R_2=dX+h.
+
+The scalar matrix has determinant 2. Reverse the four events, replacing
+doubling by halving, to restore every incoming value. The helper may have
+any h and retains its entrance value. This proves attainability of this
+response projection with two dirty carriers and a singleton clean input.
+
+The helper still contains dX at exit. This meeting preserves dX+h; it does
+not restore the original h. Preparation of aX-h, dX+h and the singleton,
+preservation of omitted public/dirty columns and later removal of dX are
+not supplied. In particular, the scalar construction is not a complete
+arbitrary-public-input endpoint or a favorable physical invoice.
+
+## Decision and remaining obligations
+
+Stop at this local result. Before expanding the architecture, identify the
+pre-cut contact depositing -h into a public register, the singleton source,
+all other dirty columns and the helper cleanup path. Preparation, native
+delivery, restoration, precision, stock, compiler and caller costs are
+unknown. None is treated as zero. There is no new kappa, supplier admission,
+all-size theorem or selected-frontier change.
+
+The proof holds over every field of characteristic different from two.
+The P104 witness is rational and dyadic. A small F3 domain is finite
+corroboration, not a formal proof-kernel certification.
+
+## Credit
+
+Matarener's PR6217 supplies the question, sign/capacity/two-source premises
+and E8 interpretation. DreamingOfClouds's PR6170 supplies frame-contract
+context. Retain the P104 carrier-code, native, helper, controller and caller
+lineage credited there. Kernel dimension, support arguments and reversible
+row operations are classical. The new contribution is their local
+correlated-dirt consequence and explicit response construction.

research/p104-wire-dirty-entry/README.md

@@ -0,0 +1,142 @@
+# A dirty-entry obstruction for a one-helper P104 wire meeting
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+A dirty helper cannot supply PR6217's missing third effective source when
+its dirt is confined to that helper at the meeting entrance. At least two
+of the three incoming registers must carry the same independent dirt. If
+exactly two carry it, the remaining clean live row must already isolate the
+exceptional third root. The two dirty live supports must cover the other
+23 ports, so each contains at least seven of them under the 16-port cap.
+
+Claim type: **scoped response-space proof with a finite local construction**.
+The result refines Matarener's explicit one-helper wire question. It does
+not decide the cost or existence of a complete one-helper program.
+
+The new kernel argument permits arbitrary finite local rational processing,
+even arbitrary linear readouts. PR6217's sign, capacity and content-in-frame
+facts are cited premises. They are not audited or replayed here.
+[PROOF.md](PROOF.md) states every hypothesis and the proof over every field
+of characteristic different from two.
+
+## Local escape and its limit
+
+At the common seven-frame for labels 11 and 19, the third root is 487.
+Two complementary six-frame sections split the live coefficients into
+parts a,d of support 15 and 8. Let e isolate the third root and c=a+d.
+The normalized Gram response rows are c+e,c-e. With prepared inputs
+
+```text
+(R0,R1,R2) = (eX, aX-h, dX+h),   h arbitrary,
+R1 += R2; R1 -= R0; R0 *= 2; R0 += R1
+(R0,R1,R2) = ((c+e)X, (c-e)X, dX+h).
+```
+
+The exact scalar map has determinant 2 and a four-event literal inverse.
+The helper retains its entrance value dX+h. Its original h is not restored
+by this meeting. Preparing the correlated pair and singleton, preserving
+all omitted public/dirty columns, legal native access and later removal
+of dX remain open. No complete signed invoice, physical saving, supplier,
+new kappa or full multiplication theorem is claimed.
+
+This is the first local result, so construction stops here. The complete
+preparation, movement, restoration, precision, compiler and caller charges
+are unknown. Their omission grants no productive credit or free operation.
+The selected record and its five framework assumptions are unchanged.
+
+## Evidence and reproduction
+
+From the repository root with CPython 3.12, standard library only:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -X dev -B research/p104-wire-dirty-entry/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -X dev -B -O research/p104-wire-dirty-entry/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/p104-wire-dirty-entry
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/p104-wire-dirty-entry --check-source-history
+```
+
+Another CPython 3.12 interpreter can replace the absolute path. Expected
+markers are `PASS_P104_WIRE_DIRTY_ENTRY`,
+`PASS_REGISTERED_RESEARCH_PACKAGE` and `PASS_RESEARCH_COMMIT_BYTES`.
+The final command requires committed bytes and full source history.
+
+The checker reconstructs this one new witness from the hash-bound port
+fixture, checks both complete 25-column projected endpoints and the
+literal inverse, and executes 625 scalar cases with arbitrary tested dirt.
+It checks all 251,559 normalized F3 cases with four live coordinates,
+three incoming rows of support at most two and nonzero dirt. Nonzero dirt
+entries are normalized to one by row scaling. A separately implemented
+augmented-matrix elimination checks every case against the kernel test.
+The feasible counts by dirt-support size 1,2,3 are 0,288,108. These are
+counts in this small normalized domain, not a census of P104 programs.
+
+Eleven rejecting controls cover each omitted event, lost doubling, isolated
+or wrong-sign dirt, changed singleton, aliasing, zero scaling and invalid
+operations. Two positive controls outside the hypotheses show why the
+support cap and nonzero dirt premise cannot be dropped. The JSON receipt
+is generated at execution and binds all six package files and the exact
+external port input by SHA256. No receipt is handwritten.
+
+No predecessor scientific executable is imported. Local normal/optimized
+and registered replay results are recorded in the submission. Hosted CI
+is a separate check, and no hosted pass is asserted before it completes.
+No Lean, Docker, native, full supplier or selected cold replay was run.
+Independent human and formal proof-kernel review are unclaimed.
+
+## Provenance and overlap
+
+Base `2485805a6d47f36ea83ddde6327d453ac82d44dc`, priority revision 8,
+selected conditional kappa .003125804. The baseline command authenticated
+source bindings only. [SOURCES.json](SOURCES.json) pins the original card,
+selected record, PR6217 proof context and runtime port fixture.
+[TASK.json](TASK.json) records the narrowed local obligation.
+
+The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19292022)
+reserves the local dirty-entry question. Live open PRs, recent account
+contributions, handoffs, active Discussions, main README terms, merged PR
+searches and local reservations were checked. Those searches omit arbitrary
+historical diffs and unpublished work; empty results are not novelty proofs.
+PR6219's A2 packing and PR6218's decoder floor address different obligations.
+No predecessor mathematical number is reverified as this deliverable.
+
+## Open next questions
+
+Can a legal pre-cut contact prepare the correlated pair and the exceptional
+singleton? Start with actual public/helper trajectories and track every
+original input column. The required dirt preload and full public endpoint
+are still missing.
+
+Can that prepared helper be cleaned while beating the matched two-helper
+route? First name its later access to dX and price all paid and productive
+histograms together. Native delivery, cleanup and a complete caller are
+blockers. These questions are also structured in TASK.json.
+
+## Credit
+
+Credit Matarener / PR6217 for the question, sign/capacity/two-source premises
+and E8 port interpretation, DreamingOfClouds / PR6170 for frame-contract
+context, and the retained P104 carrier-code, native, helper, controller and
+caller lineage. Kernel dimension, support arguments and reversible row
+operations are classical. The new material is the correlated-dirt necessity,
+its singleton consequence and the explicit local response construction.
+All predecessor files and credit lines remain unchanged.
+
+## Verifier bounds
+
+The direct call graph is acyclic. The verifier has no subprocess, network,
+write path or dynamically loaded predecessor code. There are 251,559 census
+iterations; each elimination has at most five rows and five columns. The
+P104 pass uses three rows of 25 coordinates. Scalar fixtures use four events
+in each direction, and every collection has a finite fixed bound. Functions
+are below 60 physical lines. Explicit exceptions keep checks active under
+optimized Python. Warning-strict development-mode runs and source compilation
+provide the available Python diagnostics; no external static analyzer was
+available in the selected environment.
+
+Power of Ten rule 3 requires a managed-runtime deviation. CPython allocates
+objects during execution. The fixed domains above bound live collections;
+no census results are accumulated. Each file is limited to 256 KiB,
+with one guard byte read, and file handles close on all exits. Dynamic integer
+and Fraction allocation is bounded by the fixed fixtures and operation
+counts. This is not a fixed-allocation runtime claim. A future compiled
+verifier could use fixed-capacity arrays if that becomes necessary.

research/p104-wire-dirty-entry/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "2485805a6d47f36ea83ddde6327d453ac82d44dc",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/p104-carrier-code-uniqueness/e8/ports.json",
+      "usage": "input",
+      "git_blob": "b964c3ae2ea54d3763d74639d691ea9f5b02920e",
+      "sha256": "ba6a0b9cf76b7cccc1ce8b3d1aa78a4aa329b34d45aded694648f0cf43fc9fce"
+    },
+    {
+      "path": "research/p104-wire-routing-obstructions/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "47df6ab141de73bf253b3bbceb6f09bbc7535c9b",
+      "sha256": "cbb7a9d71155f31e68eaf708ce6d0d5731914ab4777c9fd806991723ab44b223"
+    },
+    {
+      "path": "research/p104-wire-routing-obstructions/README.md",
+      "usage": "provenance",
+      "git_blob": "76dd916fc6527ceeeebedcf99c87198209bbaa39",
+      "sha256": "4de7e994de623359a9cb91319d71575965dcd2e8059b911672b1e788774f2cce"
+    }
+  ]
+}