Prove the sharp Hurwitz budget versus decoding-success law (no new κ)

research/hurwitz-budget-success/PROOF.md

@@ -0,0 +1,120 @@
+# Exact simultaneous-success tradeoff
+
+## Model and statement
+
+Retain Alexander Templeton's [PR785](https://github.com/CrocSwap/integer-mult-bounds/pull/785)
+fixed-support message model, using Douglas R. Colkitt's
+[PR703](https://github.com/CrocSwap/integer-mult-bounds/pull/703) Hurwitz geometry
+and pairing tariff. Those results are cited premises, not replayed results here.
+The new premise permits decoding errors and measures simultaneous success.
+
+There are five orthogonal mate pairs of Hurwitz lines. More generally, consider
+an abstract matching with m pairs. Every port t holds an independent uniform
+b-bit input X_t, with b a nonnegative integer. Each message j has fixed source
+support A_j, fixed reader support R_j, fixed integer width q_j, and is an
+arbitrary function of X restricted to A_j. A reader receives the whole message
+when it belongs to R_j. Each receiver also knows its mate's input for free.
+Every other observation must be included in the messages. There are finitely
+many messages. There is no input-dependent support, timing or width metadata,
+interactive relay, additional side information or correlated input.
+
+The inherited tariff c(R,A) is zero for an empty support or orthogonal singleton
+mates, one for every other case having a singleton support, and two when both
+supports have at least two elements. The charge is the fixed integer
+C_actual = sum_j q_j c(R_j,A_j). This is an abstract additive pricing premise.
+No physical nonlinear copy-cost theorem is inferred from it.
+
+**Theorem.** For any nonnegative integer budget C, the largest possible
+probability that all 2m receivers are correct is exactly
+
+    P_max(m,b,C) = 2^(-max(0, mb - floor(C/2))).                 (1)
+
+The physical Hurwitz application has m=5. The arbitrary-m assertion is about
+the stated matching tariff, without asserting that the same geometry exists
+for other m. Independent shared or private random coins do not improve (1)
+when every fixed-coin realization retains the fixed-width charge budget.
+
+## Upper bound by successful fibers
+
+A transversal T selects one endpoint of each mate pair, so there are 2^m
+transversals. Let J_T contain messages whose reader and source supports both
+meet T, and put Q_T = sum_(j in J_T) q_j.
+
+Fix every input outside T. For a fixed displayed transcript of the messages
+in J_T, there is at most one X_T assignment on which every receiver succeeds.
+Indeed, messages received in T but absent from J_T depend only on the fixed
+outside inputs. Every receiver's free mate input is also outside T. Thus each
+receiver in T has identical observations on two assignments with the same
+displayed transcript. Both assignments cannot be correct at every receiver in
+T unless their complete X_T tuples agree. This is the successful-subset
+version of Templeton's zero-error injection; correctness outside T need not be
+used for this upper bound.
+
+There are at most 2^Q_T transcripts. The conditional probability of simultaneous
+success, under the uniform mb-bit X_T, is at most min(1,2^(Q_T-mb)). Averaging
+over outside inputs leaves the same bound for the unconditional probability p.
+
+Colkitt's transversal accounting gives, for every support pair,
+
+    sum_T 1[R intersects T and A intersects T] <= 2^(m-1)c(R,A).
+
+For completeness, a zero-tariff pair never meets one transversal on both
+sides; a tariff-one pair has a singleton support, present in exactly half
+the transversals; a tariff-two pair meets at most all transversals. No
+geometry enumeration is needed for this elementary application.
+
+Consequently sum_T Q_T <= 2^(m-1) C_actual <= 2^(m-1) C. Some transversal has
+integer Q_T <= floor(C/2). Applying its successful-fiber bound and p<=1 proves
+the upper half of (1). In particular the odd-budget plateau follows from an
+integer transcript bound, rather than a continuous entropy relaxation.
+
+## Attaining construction
+
+There are mb pair-coordinate positions. Set k=min(mb,floor(C/2)) and choose
+any k of them in advance. For each chosen coordinate of mate pair {u,v}, send
+the one-bit parity X_u XOR X_v from support {u,v} to readers {u,v}. This costs
+two units per coordinate and at most C in total.
+
+For a transmitted coordinate each receiver XORs the parity with its mate's
+bit and is correct. For an untransmitted coordinate each receiver guesses
+its own bit equals its mate's bit. The two receivers are simultaneously
+correct exactly when that pair's bits agree. This has probability 1/2, and
+these equality events are independent across the mb-k omitted coordinates.
+All receivers therefore succeed with probability 2^(-(mb-k)), attaining (1).
+Unused odd budget does not help. No clean helper or physical implementation
+is being supplied by this abstract code.
+
+For random codes, fix all encoder and decoder coins independently of the
+inputs. Each resulting deterministic code satisfies the same upper bound.
+Averaging proves the random-code statement. The deterministic parity code
+already attains it.
+
+## Consequence and limits
+
+Ten one-bit ports at budgets C=0,...,10 have exact optimum success probabilities
+
+    1/32, 1/32, 1/16, 1/16, 1/8, 1/8, 1/4, 1/4, 1/2, 1/2, 1.
+
+For any b>=1, saving even one unit below the zero-error floor 10b forces
+simultaneous failure probability at least 1/2. Saving 2d units forces success
+probability at most 2^-d. These statements concern simultaneous correctness;
+individual receiver error rates have a different optimization problem.
+
+An expected-charge budget with variable execution lengths is outside (1).
+For example, choose independently of inputs between full parity delivery
+with probability r and the zero-message strategy otherwise. Its expected
+charge is 10br and its success is r+(1-r)2^(-5b), which need not obey (1)
+with C replaced by that expected charge. This example does not contradict
+Jerry Chen's PR912 zero-error expected-cost theorem. No adaptive-routing,
+variable-length or unrestricted private-header theorem is claimed here.
+
+The finite checks corroborate the proof by literal decoding and independent
+decoder optimization; they do not prove its unbounded parameters. No native
+supplier, Dfc admission, improved kappa or complete multiplication theorem
+follows from the result. Source acquisition, encoding, decoding, physical
+hosting, cleanup and tape costs remain outside this abstract charge model.
+
+This contribution was produced by Nick Petalas. The matching geometry,
+tariff, transversal method and zero-error transcript argument retain the
+predecessor credit above. No literature priority is claimed for the general
+counting method. Apache-2.0.

research/hurwitz-budget-success/README.md

@@ -0,0 +1,103 @@
+# Sharp Hurwitz budget versus simultaneous success
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+**Scoped proof with exact finite corroboration.** For ten independent uniform
+b-bit inputs in the fixed-support Hurwitz message model, the exact maximum
+probability that every receiver decodes correctly at integer charge budget C is
+
+    P_max = 2^(-max(0, 5b - floor(C/2))).
+
+Each receiver knows its orthogonal mate's input. Messages may be arbitrary
+nonlinear functions of their fixed source inputs, but supports and widths are
+fixed, and every bit pays its inherited reader/source pairing rank. The
+[proof](PROOF.md) also establishes the abstract matching-tariff formula with
+5 replaced by any positive pair count m. It covers independent random coins
+when every fixed-coin realization respects the same fixed-width budget.
+
+At b=1, budgets 0 through 10 have exact optimum probabilities
+
+    1/32, 1/32, 1/16, 1/16, 1/8, 1/8, 1/4, 1/4, 1/2, 1/2, 1.
+
+Saving one unit below the zero-error floor already forces simultaneous failure
+probability at least 1/2. A partial mate-parity code attains every step. This
+is a sharp decoding-error extension, not a new supplier or kappa improvement.
+
+## Evidence and reproduction
+
+From the repository root, using CPython 3.12 and the standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/hurwitz-budget-success/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/hurwitz-budget-success/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/hurwitz-budget-success
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/hurwitz-budget-success --check-source-history
+```
+
+The marker is `PASS_HURWITZ_BUDGET_SUCCESS`. `RESULT.json` is a generated
+receipt bound to the proof, verifier and metadata hashes. Direct replay checks
+the entire receipt without modifying any file. `--write NEW_EXTERNAL_PATH`
+generates a new receipt after all calculations; it never overwrites a receipt.
+
+The first fixture exhausts every one-bit Boolean full broadcast on two mate
+pairs. It constructs the receiver-observation conflict graph, computes exact
+maximum independent sets for all 65,536 induced graphs, and then constructs
+and literally executes optimal receiver decoders for all 65,536 encoders on
+all 16 inputs. This is independent optimization of success sets, not a replay
+of the theorem's formula or a predecessor's numbers.
+
+The attaining-code census executes all input tuples for m=1,...,5 and b=0,...,3
+with 2mb<=12, at every integer budget 0,...,2mb+2. The code sends selected
+pair-coordinate parities and decodes all receivers. Controls distinguish
+upward rounding of odd budgets, independent guesses instead of mate guesses,
+omitted parity, conflicting successful inputs and invalid parameters. A
+correlated-input boundary example succeeds with zero charge and explains why
+input independence matters. Counts and the complete encoder histogram are in
+the generated receipt. The written proof supplies the all-width result.
+
+## Scope and predecessor credit
+
+Alexander Templeton's merged [PR785](https://github.com/CrocSwap/integer-mult-bounds/pull/785)
+supplies the fixed-support nonlinear model and zero-error transcript argument.
+Douglas R. Colkitt's [PR703](https://github.com/CrocSwap/integer-mult-bounds/pull/703)
+supplies the Hurwitz matching geometry, tariff and transversal accounting,
+following Joel Pulikkan's [PR620](https://github.com/CrocSwap/integer-mult-bounds/pull/620).
+Jerry Chen's [PR912](https://github.com/CrocSwap/integer-mult-bounds/pull/912)
+treats paid adaptive headers and expected zero-error charge. It is a separate
+boundary, not an input to this proof. Historical proofs are pinned as
+provenance in `SOURCES.json`; no predecessor verifier or geometry is replayed.
+No priority is claimed for the general successful-subset counting method.
+
+Only the decoding-error premise changes. Uniform independent inputs, fixed
+supports and widths, mate-only free side information, and additive per-bit
+pricing remain essential. Expected-charge budgets, adaptive routing,
+interactive relays, correlated inputs and additional side information are
+outside scope. Physical encoding, decoding, cleanup, hosting and tape costs
+remain unknown; no native operation is installed. There is no selected-frontier
+change or complete multiplication theorem. Independent human and formal
+proof-kernel review are unclaimed.
+
+This is a changed-scope side result under `complex-rank-shape-decoder`.
+The card's 5% supplier ceiling acceptance gate is not claimed passed. The
+family expansion decision is to finish this sharp obstruction and stop;
+no dependent construction campaign or selected cold replay is justified.
+The base is `624de9dc66858af0945e5f8a0942488d62280d43`, priority revision 7.
+
+## Open next questions
+
+The structured questions in `TASK.json` concern individual receiver errors
+and unequal paired widths. For the first, start with exact achievable error
+vectors on two one-bit mate pairs. For the second, start with widths
+(1,2,1,1) on two pairs. The present joint-success theorem and uniform
+transversal dimensions do not settle these questions.
+
+## Code verification limits
+
+The verifier uses structured, nonrecursive loops. Its exhaustive Boolean
+tables have 65,536 entries; literal witness inputs have at most 12 bits.
+Managed Python allocations are an explicit Power of Ten deviation: lists,
+integers and temporary tuples allocate during the scan, with live memory
+bounded by those fixed domains. No callback dispatch, subprocess, network,
+external source import or generated code occurs. Every function is under
+60 physical lines. Checks use explicit exceptions and remain active under
+optimized Python. Warning-strict normal and optimized execution are registered.

research/hurwitz-budget-success/RESULT.json

@@ -0,0 +1,36 @@
+{
+  "boolean_broadcast_census": {
+    "boolean_encoders": 65536,
+    "induced_graphs": 65536,
+    "literal_input_tuples": 1048576,
+    "optimal_success_histogram": {
+      "4": 1810,
+      "5": 17632,
+      "6": 28256,
+      "7": 15136,
+      "8": 2702
+    }
+  },
+  "claim_type": "scoped proof",
+  "controls": {
+    "correlated_boundary": "1",
+    "odd_budget": "1/2",
+    "rejected_invalid_cases": 5,
+    "zero_budget_ten_ports": "1/32"
+  },
+  "new_kappa": false,
+  "schema": "hurwitz-budget-success/1",
+  "source_sha256": {
+    "PROOF.md": "7c94c46e72ae69846fd45ce5972bfdd09a5c2dae233d04575d062c3ba4b15b1f",
+    "README.md": "9740baebf15b4609a6a92290719ab89b8b29ed45fb21df9c2bf362a5a618e8a3",
+    "SOURCES.json": "414a978d97fcb65b36dd251f6b3e35db08b1e2c383cbf3c7ee8689e648688cd1",
+    "TASK.json": "b790f9e7eff48bf38b7cf344a43ad376f2067710158e72bcfd5d49de1b8ade93",
+    "VERIFY.json": "e697bbb22797e4db7c59b908540dbdf5b7735ad179e026c6ae0c4be01abaa702",
+    "verify.py": "3ceefa0bbb56a840020dd62e717243c666913496f9777312881679cb560126b0"
+  },
+  "witness_census": {
+    "cases": 117,
+    "input_tuples": 143235,
+    "rows_sha256": "d25f68b503faff1e566e708676174a910b25b1cca159439964e64814d7157bfa"
+  }
+}

research/hurwitz-budget-success/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43",
+  "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/hurwitz-adaptive-routing/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "915a91663e8ae2eb96a2c248224a40ec052e6fda",
+      "sha256": "612d1723fd855503384943217b78f18a80adaca074196aa677b7124845d9e4d1"
+    },
+    {
+      "path": "research/hurwitz-nonlinear-copy-floor/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "9811bf631707a087086f2efb1c2eb6db24eab20c",
+      "sha256": "62206654c5e6928324563bd5883db7186917a4546126ae64b72eee8914d9f573"
+    }
+  ]
+}