Sharpen selected nested widths to K/N < 3.0694 (no new κ)

research/fractional-source-width/README.md

@@ -0,0 +1,176 @@
+# A fractional-moment bound for selected nested widths
+
+This package was produced by Nick Petalas. Apache-2.0.
+
+**Scoped mathematical proof, with exact finite corroboration.** For the unchanged
+selected #4470 invoice, product power 1024, completion floor and paid split rule,
+the #4436 nested compiler satisfies `K/N < 3.0694`.
+
+This improves JoyboyBrian's [#5067](https://github.com/CrocSwap/integer-mult-bounds/pull/5067)
+bound `K/N < 3.070`. More precisely, its uniform source logarithm bound
+`197115103572543` decreases to `197100824008381`, a reduction of
+`14279564162`. The new step is a fractional source-rank moment, including
+completion and splitting. The selected kappa remains `60403/20000000`.
+This is a mathematical width bound under the retained compiler assumptions;
+physical stock, routing, native realization and supplier admission remain open.
+
+## Premise and new uniform inequality
+
+Use the source-labelled root/nonroot census and strict source-rank interval
+proved in #5067 as cited premises. They are not independently audited here.
+Write `M` for ambient rank, `L>=2` for the completed productive floor,
+`x=n/M`, and `G=max{g:M L^g<=n}`. Let `T_k` and `P_r` be the fully completed
+and split productive and paid inventories. The cited census includes every
+nonroot absent-parent demand, with distinct chronological labels, and each
+source rank `s` obeys `x<s<=n`.
+
+For any real `p>0`, define `T_p=sum T_k k^p` and `P_p=sum P_r r^p`.
+Each source contributes `1<(s/x)^p`. Sum this weight over the cited exact
+census, then enlarge the eligible sets to full ordered words. Multiplicativity
+of `(ab)^p` gives root weight `T_p^(G+1)` and depth-d weight
+`P_p^d T_p^(G-d+1)`. Thus the new inequality is
+
+```text
+S_n < x^(-p) T_p sum_(d=0..G) P_p^d T_p^(G-d).       (1)
+```
+
+If a common `U` bounds both `T_p` and `P_p`, then
+
+```text
+S_n < (G+1) U^(G+1)/x^p
+    <= (G+1) U (U/L^p)^G.                           (2)
+```
+
+This does not assume `P_p<=T_p`. Rank-mass ordering at p=1 alone does not
+imply that ordering at a fractional p.
+
+## Charging the actual completion and splitting
+
+Let `t_p=sum T0_k k^p` and `q_p=sum P0_r r^p` be moments of the pinned raw
+invoice, `W0=sum T0_k`, and `q_1=sum P0_r r`. The chronological product power
+is `v=1024`, the completion floor is `L=21^v`, and split cutoff is `J=20^v`.
+The product has `W0^v` productive slots. Completion adds at most `L` to
+each slot on disjoint coordinates, so
+
+```text
+T_p <= t_p^v + W0^v L^p.
+```
+
+For a paid rank `a`, write `a=bJ+c`, `0<=c<J`. Its actual split p-moment is
+`b J^p+c^p`, with the zero remainder omitted. Since
+`b J^p <= a J^(p-1)` and `c^p<=a^p`, it is at most
+`a J^(p-1)+a^p`. Applying this to every raw product call and every completion
+call gives
+
+```text
+P_p <= q_p^v + q_1^v J^(p-1)
+       + W0^v (L^p + L J^(p-1)).                  (3)
+```
+
+Every term in (3) is retained. Small unsplit calls enter `q_p^v`; rank mass
+alone cannot bound a concave split moment. The proof permits arbitrary
+completion deficits within the actual floor, without materializing their
+histogram or declaring their costs zero.
+
+Choose `p=511/512`. Then `L^p=21^1022` and `J^(p-1)=1/400` exactly.
+The verifier encloses each raw rank power on a dyadic grid of mesh `2^-24`.
+For the upper numerator `b_k`, it checks the integer inequality
+
+```text
+(b_k-1)^512 <= k^511 * 2^(24*512) <= b_k^512.
+```
+
+It sums the upper rational endpoints with the literal raw multiplicities,
+raises them to power 1024, and compares the complete bounds above with
+`U=2^18291`. Both are strictly smaller than U. No floating-point evaluation,
+external numerical library or predecessor executable supplies these comparisons.
+
+## Accumulating the width
+
+Use the unchanged selected `H=64215200000000`, `N=2^H`, `M=145^1024` and
+`B_n=B_(n-1) S_n`, with base width one. Exact integer bit lengths give
+
+```text
+G(n) <= h = 14279564152       for M<=n<=N,
+floor(log2 L^p) = 4488,
+U/L^p > 1.
+```
+
+Taking logarithms in (2) and bounding by integer bit lengths yields
+
+```text
+log2 S_n < bit_length(h+1) + 18291 + h*(18291-4488)
+         = X = 197100824008381.
+```
+
+Therefore `log2 B_N<NX`. The integer `NX` bounds `ceil(log2 B_N)`, so
+`K/N<=X/H`. The exact integer comparison `10000 X < 30694 H` proves the
+stated `3.0694` bound. This argument uses a uniform envelope; it assumes no
+monotonicity of the exact source count. The permitted nested widths and
+complements remain as in the cited compiler, with no changed physical tariff.
+
+## Reproduction and evidence
+
+From the repository root, CPython 3.12 and standard library only:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B -W error research/fractional-source-width/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -B -W error research/fractional-source-width/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/fractional-source-width
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/fractional-source-width --check-source-history
+```
+
+Any CPython 3.12 installation can replace that interpreter path. Expected
+marker: `PASS_FRACTIONAL_SOURCE_WIDTH K/N<3.0694 no_new_kappa`.
+The verifier prints exact root intervals, the new integer X, finite fixture
+counts and a generated SHA256 receipt for all package files. No receipt is
+hand-written or committed. The 458 new tiny ordered-word fixtures corroborate (1)-(2)
+at p=1/2, and 32 actual split-moment fixtures corroborate (3). Discriminating examples
+show why omitting split mass, assuming paid/productive moment ordering or
+rounding a rank power downward is unsafe. They do not rerun predecessor
+source-count fixtures or certify its census independently. Checks use explicit
+exceptions and remain enabled under `-O`.
+
+The written proof establishes the uniform claim. Finite tests corroborate it.
+Independent human and formal proof-kernel review are unclaimed. The selected
+source-binding orientation passed and was metadata orientation only. No Lean,
+Docker, selected operator replay or physical implementation was run. All
+registered package checks ran locally; hosted CI is reported in the PR.
+
+The verifier has no recursion, subprocesses or configurable search bounds.
+Its fixed domains have rank at most 145 and at most 33 bisection steps per
+rank; the toy paths have depth at most four. Functions have fewer than 60
+lines. Python allocation during exact arithmetic is a managed-runtime
+deviation from fixed allocation, bounded by these finite inventories and
+fixed exponents. No library allocation audit is claimed. Warning-strict normal
+and optimized execution provide the available diagnostics; repository-wide
+static-analysis configuration is unchanged.
+
+## Open next questions
+
+1. Can a boundary-sensitive moment or a different fixed exponent tighten the
+   mathematical width further? Start with (1) and preserve every term in (3).
+   Optimal exponent and optimal width remain unknown. No optimization campaign
+   is performed here because the first improvement meets the stop rule.
+2. Can the permitted width be realized by the actual fixed-program
+   stock/ownership/routing interface at its full tariff? Choose one caller
+   before extending arithmetic bounds. Native/all-column, whole-job, precision,
+   tape and analytic/recovery assumptions remain separate obligations.
+
+## Credit and scope
+
+Produced by Nick Petalas. This answers Open next question 1 of JoyboyBrian's
+#5067 by extending its first-moment argument. Credit Sagar Thakrar #5026,
+James Reed/jwr404 #4972/#4970, Mark/Matarener #4612, zxv #4436, Cinna Davis
+and zxv #4440/#4470, Jacob Alan Sussman's Theorem 1G, Ryanson Jonathan and
+mihir-s-05, together with the lineage retained in #5067. Predecessor credit
+lines and files are unchanged. No claim of literature priority is made for
+the elementary moment method or the splitting inequality.
+
+The selected-stock-envelope card is changed to a scoped mathematical compiler
+width result, following a concrete other-contributor handoff. This does not
+discharge the card's physical stock question. SOURCES.json pins the census
+statement and raw invoice at main `81e9bd69e4a5b00ba9c713a1620e36d576d5522e`.
+Live and merged overlap checks, recent account work and local reservations were
+consulted before the [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19142685).
+Unpublished work and arbitrary code diffs remain outside that coverage.

research/fractional-source-width/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e",
+  "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/selected-truncated-source-envelope/README.md",
+      "usage": "input",
+      "git_blob": "90eef1e03f6a1c45a8ce7223e477f5eafa4819de",
+      "sha256": "2f9e6bfa32a529305aaf7a5865215eb37ad0e8290077decc5bc76d02eb48f179"
+    },
+    {
+      "path": "research/selected-truncated-source-envelope/vendor/selected.json",
+      "usage": "input",
+      "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596",
+      "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21"
+    }
+  ]
+}

research/fractional-source-width/TASK.json

@@ -0,0 +1,101 @@
+{
+  "schema_version": 1,
+  "task_id": "selected-stock-envelope",
+  "priority_revision": 7,
+  "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e",
+  "original_card": {
+    "id": "selected-stock-envelope",
+    "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?",
+    "starting_points": [
+      "research/selected-bootstrap-stock-audit/README.md",
+      "research/bootstrap-cutoff-time-space-split/README.md",
+      "certificates/selected-result.json",
+      "docs/research/community-efficient1000-review.md",
+      "research/stock-margin-chain/README.md"
+    ],
+    "methods": [
+      "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.",
+      "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope."
+    ],
+    "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read #2972 stock-margin chain and the selected stock audit. The new source archive reports the remaining cutoff comparisons, but leaves every actual stock coefficient unresolved; it is not an independently validated reserve envelope.",
+      "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission."
+    },
+    "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.",
+    "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.",
+    "allowed_variations": [
+      "One stage or one explicit reserve/depth implication.",
+      "An independently checked same-domain proof repair, retaining all remaining assumptions."
+    ],
+    "scope_change_triggers": [
+      "Importing the historical 57604 or 252 allowance without a selected-producer binding.",
+      "Calling a conditional fit lemma a full outer-proof adoption.",
+      "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality."
+    ],
+    "overlap_terms": [
+      "selected stock",
+      "stock envelope",
+      "bootstrap cutoff",
+      "1956",
+      "1965",
+      "1990",
+      "2972",
+      "stock-margin-chain",
+      "actual_stock_coefficient"
+    ],
+    "existing_checks": [
+      {
+        "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.",
+        "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation",
+        "remaining": "Derive one actual reserve/depth coefficient from the selected producer.",
+        "status": "reviewed",
+        "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Prove a fractional source-rank moment bound K/N < 3.0694 for the unchanged selected nested compiler, including completion and splitting.",
+  "scope_change_reason": "Take JoyboyBrian #5067 Open next question 1, a mathematical compiler-width side result. Physical stock realization is not claimed.",
+  "bottleneck_link": "Reduce a proved nested mathematical width envelope without changing selected kappa or treating it as physical stock admission.",
+  "budget_minutes": 60,
+  "stop_rule": "Ship the first verified strict improvement over #5067; do not optimize the exponent afterward.",
+  "outcome": "completed",
+  "evidence": "README.md written proof and verify.py exact integer/rational replay with generated hash receipt.",
+  "author": "Nick Petalas",
+  "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.",
+  "open_questions": [
+    {
+      "question": "Can a boundary-sensitive moment further tighten this mathematical width?",
+      "why_it_matters": "Reduce permitted compiler width.",
+      "first_step": "Preserve the exact root/nonroot census and every term of equation (3).",
+      "blocked_by": "No optimality theorem for the common moment envelope."
+    },
+    {
+      "question": "Can the actual stock/ownership/routing implementation realize this width at its complete tariff?",
+      "why_it_matters": "A mathematical width envelope is not a physical supplier.",
+      "first_step": "Choose one actual caller with explicit ownership and tape charges.",
+      "blocked_by": "Native, whole-job, storage, precision and analytic obligations remain inherited."
+    }
+  ],
+  "environment": {
+    "python": "3.12.15",
+    "platform": "darwin",
+    "dependencies": "standard library only"
+  },
+  "predecessors": [
+    {
+      "pr": 5067,
+      "author": "JoyboyBrian",
+      "head": "103f8130fe617e8c720af4cb6ce63cf638085d76",
+      "usage": "Cited exact source census and open fractional-moment handoff; not audited."
+    }
+  ]
+}

research/fractional-source-width/VERIFY.json

@@ -0,0 +1,35 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/selected-truncated-source-envelope/README.md",
+    "research/selected-truncated-source-envelope/vendor/selected.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "-W",
+        "error",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact fractional powers, fully charged moment ceilings, source-width bound and tiny new fractional-moment fixtures."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-O",
+        "-B",
+        "-W",
+        "error",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Same proof-relevant checks with optimized execution."
+    }
+  ]
+}