Reduce PR5413 carrier height at fixed κ and certify size-saving tradeoffs

research/pr5413-carrier-frontier/.gitattributes

@@ -0,0 +1 @@
+* -text -filter

research/pr5413-carrier-frontier/NOTICE

@@ -0,0 +1,16 @@
+PR5413 carrier size-saving frontier
+Copyright 2026 Richard Hoekstra
+New package material is provided under the repository's Apache License 2.0.
+Prepared with substantial OpenAI Codex assistance.
+
+This package reuses authenticated public arithmetic and application sources:
+Chris R / Clear1nsight's PR5413 caller audit, exact moments, precision checker
+and conjunction; zxv's higher-moment/logarithmic compiler and precision work;
+Jacob Alan Sussman's integer mixed-target flow; Cinna Davis's product/helper
+lineage; Dillon Amburgey's provider; Ali Romman's direct controller; Cao Yifan's
+native construction; and the cumulative BIT, Clifford, analytic and verification
+contributors credited in those frozen packages. PR5468's gap-parametric checker
+provides related precedent but is not a dependency or a changed-tuple admission.
+
+No third-party source files are copied into this package. Public dependencies
+retain their original notices and are declared and authenticated by exact paths.

research/pr5413-carrier-frontier/PROOF.md

@@ -0,0 +1,134 @@
+# Changed-tuple carrier application to the frozen PR5413 caller
+
+This is a conditional application of the existing higher-moment and logarithmic
+compiler theorems. The raw native word, all-column/owner contracts and the five
+selected framework assumptions remain premises. No new raw profile or root is
+claimed. Source paths, exact Git blobs and SHA256 are in SOURCES.json.
+
+## 1. Complete paid charge
+
+The source has 10,928 productive fields, 64,260 paid jobs and ambient rank 145.
+For raw moments T_t and P_t, tested saving s, t=1-s, u>=s and integer v>=1, put
+
+```
+alpha=P_t/T_t,
+gamma=P_(t+u)/(c^u*T_t),
+delta=10928*b/(c^s*T_t),  1<c<b<145.
+```
+
+The higher-moment theorem in `research/higher-moment-strictification/README.md`
+applies to the chronological v-fold product, completion to at least b^v on each
+actual productive owner, and splitting at c^v. Its complete normalized upper
+bound is `alpha^v+2*gamma^v+2*delta^v`. For R>J, the final incomplete split block
+is included in `q*J^t+r^t<=2*R*J^(-s)`; the higher moment is valid because
+`t+u>=1`. Completion includes the same final-block allowance and every owner.
+The final productive moment is at least the raw T_t^v, so normalization by that
+smaller quantity is conservative. No new field or unpaid child is introduced.
+
+The old `.97` bounds and `4/2^32` debit were sufficient upper estimates of those
+same charged jobs. The new certificate evaluates all three terms directly with
+outward rational bounds. It does not add the old sufficient debit as a second
+copy of physical work. In particular the fixed-kappa point has gamma>.97 but
+its full paid bound is still strictly below one. The source's old conjunction
+correctly rejects that point; its changed application is explicit here.
+
+The public `exact_moments.py` helper is authenticated and reused with attribution,
+not called an independent implementation. Its rational logarithm/exponential
+enclosures are rounded outward before integer powers; each positive paid term
+is rounded upward again, and their exact sum must be below one.
+
+## 2. Logarithmic majorant
+
+For theta=A/D<1, the inherited theorem requires
+
+```
+c^D < b^A,
+2^(D-A)*c^(v*D) <= 145^(v*A),
+theta^p < (1-s)*145^(-v*s),
+145^(v*s) < 2^p,   p a positive integer.
+```
+
+All are checked with integers or directed rational bounds. They imply the
+source compiler's normalized leaf bound
+`L(n)<=n^(1-s)*(1+log2 n)^p`. For declared saving k use the inherited slack
+family d=(s-k)/7, uniform=k+6d, b_outer=k+5d, a_outer=k+4d, q_outer=k+3d,
+epsilon=1-d, beta=1-3d, r0=d/10 and stop=layout=d. The actual source ledger's
+54 strict predicates, four functional guards and nine cost rows are recomputed.
+The ordinary BIT saving .0034 and atom .004 remain fixed and funded.
+
+## 3. A rational-gap carrier grid
+
+Set `H_j=ceil(j/d)` for positive integers j. A successful grid point obeys
+`H_j>8v` and `(H_j+1)^p<2^j<=2^(d*H_j)`. Thus at N=2^H_j the leaf bound is
+strictly below `N^(1-s+d)=N^(1-uniform)`. The new construction does not require
+the numerator of d to be one; every rank and program count remains integral.
+
+For the implemented domain `0<d<1/16`, the binary search finds the first j:
+
+- If `j<=4p`, then `H_j>=1/d>16`, hence `(H_j+1)^p>2^(4p)>=2^j`.
+- For `j>=4p`, `H_(j+1)-H_j<=ceil(1/d)`. Therefore
+  `(H_(j+1)+1)/(H_j+1)<=1+(1+d)/j`. Raising this ratio to p gives less than
+  `exp(17/64)<2`, using `log 2>1/2`. The left comparison grows by less than
+  two while the right comparison doubles. Once the grid succeeds it stays
+  successful, and the preceding tested grid point fails exactly.
+
+No minimal integer H, global compiler optimum or maximal kappa is claimed.
+
+## 4. Fresh finite-template and precision application
+
+The original V16 application proof already counts the actual source's 145-axis
+maps, 418 private fields, scalar/ordinary records and dyadic coefficient height
+below A0=2^128. Those data and all raw source/field-ID/route bindings are unchanged.
+For product v, the same strictified-unit overestimate becomes
+
+```
+2*(v*(2+2*128)+10+2*(8v))+6+3*(8v+1)=572v+29.
+```
+
+It remains below 1048576 on the declared v<=1024 domain. Keep the conservative
+original `D0=2^1048576`, and reapply exactly the same constructive F16 recursion
+at the new N. No count from the raw template is silently reused as an expanded
+count. The resulting M=F16(N) bounds W,P,U,O,R,G, with the source's updated
+ordinary/precision/parked-stock prescriptions. D0 and M enter eventual outer
+constants, not a claim that they fit below N^d. All relevant outer gaps remain
+strict. The tensor product, paid completion and disjoint splitting are the
+retained finite algorithm, including their complete owners and whole-job adapters.
+
+`application.py` verifies seven numerical substitution sites in the accepted
+V16 proof and inserts the preceding complete-charge/grid application paragraph.
+It builds each full instance only in scratch and binds its SHA256 in the source
+and conjunction manifests. The generated precision checker changes three exact
+source sites: product/ambient-log parameters, positive rational gap, and the
+positive-power ceiling-grid checks. On the original manifest it reproduces the
+entire original precision payload except timing/checker/manifest hashes.
+
+The conjunction adapter changes six named applications: endpoint/gap, complete
+moment funding, partial-block charging, carrier grid, fresh F16 count bound and
+the instantiated proof hash. The old fixed-envelope minimum-reserve gate becomes
+an explicit complete paid-sum gate. The other 19 conditions are compared in the
+AST and stay unchanged, including complete profile equality, actual owners,
+all-column source packet/phase/route bindings, ordinary BIT/stock and component
+false flags. All 25 adapted conditions pass for each point. This is a new
+conditional application receipt, not an upstream approval or proof-kernel result.
+
+## 5. Replay coverage and remaining premises
+
+Every registered replay first runs the unchanged complete PR5413 eight-engine
+master and compares its frozen outputs. Those source-identical native, local,
+whole-caller, field-ID and invoice results are reused across the five new tuples.
+Each tuple then has fresh directed funding, full outer checks, generated written
+application, precision check and conjunction. Meaningful controls reject the old
+coarse application, a preceding carrier grid, product outside the declared safe
+domain, a missing paid job, free completion and an invalid higher-moment offset.
+
+The five premises are unchanged: native_all_columns, owned_erasure, compiler,
+precision_tape and analytic_recovery. No uniform word or physical Turing tape is
+materialized, no independent human verification is claimed, and no practical
+runtime improvement follows from the smaller sufficient carrier.
+
+Credit the source higher-moment/log compiler to zxv; mixed-target flow to Jacob
+Alan Sussman; chronological products/completion and helpers to Cinna Davis and
+the retained lineage; PR5413 application/checkers to Chris R/Clear1nsight, using
+Dillon Amburgey's provider, Ali Romman's controller and Cao Yifan's native word.
+Richard Hoekstra prepared this application with OpenAI Codex assistance.
+New work is Apache-2.0; source-specific notices remain in the frozen inputs.

research/pr5413-carrier-frontier/README.md

@@ -0,0 +1,127 @@
+# Smaller PR5413 carriers at fixed saving, with certified size-saving tradeoffs
+
+For the unchanged complete PR5413 raw caller, the sufficient height H in N=2^H
+falls **3.20324× at exactly the same conditional κ=.003027288235**. Four
+explicitly weaker declared savings give smaller carriers, including a
+31.1-million-fold H reduction at κ=.003. These compare sufficient construction
+bounds, not measured multiplication runtimes or globally minimal templates.
+The selected frontier, raw profile, raw root and five framework assumptions
+are unchanged. No practical-size word or full unconditional theorem is claimed.
+
+| Declared κ | Product v | Log power p | Sufficient H | PR5413 H / H |
+| --- | ---: | ---: | ---: | ---: |
+| Published .003027288235 | 1024 | 1000 | 38569300000000000 | 1 |
+| Same .003027288235 | 1024 | 322 | 12040700000000000 | 3.20324 |
+| .003 | 512 | 120 | 1239850102 | 31108034.7 |
+| .00275 | 256 | 59 | 50859231 | 758353975 |
+| .0025 | 256 | 58 | 25258797 | 1526965041 |
+| .002 | 256 | 55 | 11738348 | 3285751964 |
+
+The κ=.003 point retains about 99.1% of the PR5413 exponent saving. The large
+height factors at lower κ explicitly spend exponent headroom; they do not
+preserve the original exponent. Even the smallest carrier remains astronomical.
+
+## What changes and what is reused
+
+The fixed-κ tuple uses cutoff18/floor21, higher-moment offset1/10,
+theta61/64 and logarithm power322. The lower-saving tuples use cutoff17/floor21,
+offset1/10 and theta15/16, with the exact tested exponents in [RESULT.json](RESULT.json).
+All 64,260 paid jobs and 10,928 productive fields of the raw caller are retained.
+
+The existing higher-moment theorem pays the complete normalized sum
+`alpha^v+2*gamma^v+2*delta^v`. Evaluating that sum directly replaces the old
+sufficient `.97`/Bernoulli tail envelope and permits the changed tuple. Both
+partial-block remainders and all target completions stay charged. It is not
+enough to substitute a smaller logarithmic power in the old pinned checker.
+
+The existing logarithmic compiler and positive slack family then fund the new
+carrier. [PROOF.md](PROOF.md) gives the complete charge, rational-gap ceiling
+grid, fresh finite-template application and remaining assumptions. [application.py](application.py)
+makes the exact source substitutions in scratch. It generalizes three precision
+sites, checks conservativity on the original payload, and changes six named
+conjunction applications. The other **19 of 25 source conditions are unchanged
+in the AST**, including all owner/phase/route/field-ID checks and false component
+flags. All 25 adapted conditions pass for each new point. The one old minimum
+reserve-envelope gate is explicitly replaced by a full paid-sum condition.
+
+Every replay first runs the **unmodified complete eight-engine PR5413 master**.
+Its source-identical native/local/wholecaller/binding/invoice evidence is reused
+across the five tuples; funding, outer inequalities, precision and conjunction
+are fresh for each tuple. Frozen source files are never edited. The original
+arithmetic helpers and outer ledger are authenticated and reused with credit;
+this package does not claim an independent implementation of those helpers.
+
+Meaningful controls reject the unsubstituted coarse application, a preceding
+height grid, product outside the declared safe domain, a missing paid job,
+free completion and an invalid higher-moment offset. All 54 strict and four
+functional outer predicates remain funded. Component flags retain their narrow
+scope; a successful adapted conjunction is not upstream scientific approval.
+
+## Relation to previous work
+
+zxv's higher-moment/logarithmic compiler already reduced earlier sufficient
+carriers substantially. PR5468 supplies gap-parametric precision on the same
+caller with the original tuple fixed. This contribution applies a changed
+fully charged tuple at fixed κ and records a size-saving frontier, rather
+than more digits of the raw root. It is neither a new strictification theorem
+nor the first parametric precision application. The raw native/provider/
+controller and complete conditional-framework lineage keep full credit.
+
+This was an explicitly assigned finite-size investigation. Its changed scope
+from the historical `independent-moment` card is in [TASK.json](TASK.json).
+Exact base/source blobs and hashes are in [SOURCES.json](SOURCES.json); the
+current selection and catalogue are historical provenance. A bounded public
+PR-title/body search included PR5413/5462/5468 and the exact new H value; it
+is not an exhaustive novelty proof. No selected-record update is requested.
+
+## Reproduce and inspect
+
+Python standard library only; generic environment Python 3.12. From repo root:
+
+```sh
+python3 -B scripts/research_package.py --package research/pr5413-carrier-frontier --check-only
+python3 -B scripts/research_package.py --package research/pr5413-carrier-frontier
+```
+
+To retain each generated full written application and exact precision/conjunction
+review diff, with no frozen-source edits:
+
+```sh
+python3 -I -B research/pr5413-carrier-frontier/verify.py \
+  --proof-output /tmp/carrier-frontier-review
+```
+
+`--write` rebuilds the committed scientific RESULT for authoring; the normal
+command compares the complete deterministic payload. Both wrapper modes compile
+scientific source with optimize=0. Local checkout modes must match the frozen
+capsule manifest; a group-writable local umask may require restoring its declared
+0644/0755 modes before the unchanged master can run. Hosted CI is separate from
+local Linux replay. No Lean or actual Turing-tape execution is supplied.
+
+Local validation passed on Linux with CPython 3.12.13: the upstream metadata/pin
+check and both registered ordinary/optimized replays, each including the complete
+eight-engine baseline, all five changed applications and the rejection controls.
+Ruff also passed for the three new Python files. The package preserves exact
+source bytes across checkout filters; publication and Git-free export checks
+are recorded separately in the PR handoff.
+
+## Open next questions
+
+1. Independently review the source-sensitive tuple application. Start with the
+   six changed conditions, complete paid-tail proof and generated proof diffs.
+   This matters because numerical success is not human or proof-kernel review;
+   none is claimed here.
+2. Apply a different compiler geometry to this exact raw caller with a full
+   ordinary/precision bill. Smaller sufficient carriers still do not give a
+   practical runtime. A favorable raw moment alone does not supply that caller
+   or its convergence/implementation gates.
+
+## Credit
+
+Richard Hoekstra prepared this package with substantial OpenAI Codex assistance.
+Chris R/Clear1nsight supplied the PR5413 caller audit, exact arithmetic and
+precision/conjunction checks; Dillon Amburgey the provider; Ali Romman the direct
+controller; Cao Yifan the native word; Cinna Davis the helper/product lineage;
+zxv the compiler/precision/higher-moment machinery; Jacob Alan Sussman the mixed
+flow. Retain the full cumulative source attribution and notices. New material
+is Apache-2.0. No independent human or formal-kernel approval is claimed.