Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
169 changes: 169 additions & 0 deletions research/additive-plateau-width/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,169 @@
# A minimum-decrement divisor for chronological widths

This contribution was produced by Nick Petalas. All integers below are exact.
The recurrence and its separated-flow properties are credited premises from
Jerry Chen / CubeJerry [#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424),
head `d622d8c62defa9defeb95741e88b33a120044866`, PROOF.md sections 1–4.
That work extends #7345, codyw912 #4638 and Mihir Srivastava #4507/#5071.
The new step is the additive plateau visit bound and its width divisor.
No predecessor theorem is audited here.

## 1. Boundary and inherited recurrence

Fix positive integer target multiplicities W_k and paid-site multiplicities P_r,
with finite nonempty supports satisfying

```
2 <= k_min <= k <= m <= A, 1 <= r <= r_max < k_min.
```

Each occurrence of a paid site and each chronological path remains distinct.
Let Gamma be the multiplicative semigroup generated by target and paid ranks,
including 1. Write gamma_next for the successor of gamma in Gamma. It exists
because k_min*gamma is in Gamma. For n < A let B_n=1. At n >= A the credited
flow supplies fresh-source multiplicities t_s > 0, their total S=sum_s t_s,
and a nonempty list of individual exit ranks e. Its least replication is

```
a_n = lcm( {B_(n-s)/gcd(B_(n-s),t_s): s<n}
union {B_e: each individual exit} ),
B_n = S*a_n.
```

Sources with s=n have no complement. A source multiplicity groups only
identical-rank fresh sources, before complement consumption. Equal-rank exits
remain separate chronological cuts: their repetition count never divides B_e.
The construction's source, exit and unit censuses are constant on

```
A*gamma <= n <= A*gamma_next - 1.
```

Every source rank s belongs to Gamma, satisfies s>gamma and s<=A*gamma,
and hence s>=gamma_next. These properties follow from the credited fresh-source
floor s>n/A and the product form of source ranks, evaluated at the plateau's
first rank. Every exit has

```
e <= r_max*k_min^G <= r_max*gamma < A*gamma,
```

where G=floor(log_(k_min) gamma). Thus every paid exit leaves this plateau.
These statements specify the exact application boundary of the theorem.

## 2. New visit bound

Fix a maximum N>=A and an observed plateau gamma<=floor(N/A). Put

```
L_gamma = A*gamma,
U_gamma = min(N, A*gamma_next - 1),
delta_gamma = min{s: t_s>0},
nu_gamma = 1 + floor((U_gamma-L_gamma)/delta_gamma).
```

Consider any directed recursive rank chain starting at a rank <=N. Every edge
strictly decreases its rank, so its visits to one plateau are contiguous. An
edge that remains on that plateau cannot be an exit. It must be a complement
n -> n-s, which decreases rank by at least delta_gamma. If the chain visits
this plateau v times, its first and last such ranks differ by at least
(v-1)*delta_gamma, and by at most U_gamma-L_gamma. Therefore

```
v <= nu_gamma.
```

There is no logarithmic estimate or real-power rounding in this argument.
This visit bound is attained in the numerical recurrence: start at U_gamma
and repeatedly take the positive-count complement with s=delta_gamma until
it leaves the plateau. All intermediate ranks lie in [L_gamma,U_gamma], where
the source census is unchanged. If this process takes another edge while
remaining in the plateau then its child is positive, so that complement exists.
Thus the actual maximum number of visits is exactly nu_gamma.

A useful uniform consequence is

```
nu_gamma <= ceil(A*(gamma_next-gamma)/delta_gamma)
<= ceil(A - A*gamma/gamma_next)
<= A-1.
```

The last inequality uses gamma_next<=k_min*gamma<=A*gamma. This also shows
nu_gamma is always smaller than the previous common visit exponent
`tau=A*ceil(log2 k_min)`, which is at least A. Truncating the last plateau
can improve it further. In particular the minimum with the inherited tau,
proposed in the advance claim, equals nu_gamma on this application boundary.

## 3. New all-prime divisor

For any prime p, including a prime absent from the rank alphabet, the LCM
recurrence gives

```
v_p(B_n) <= v_p(S_n) + max_child v_p(B_child).
```

The gcd can only lower a complement child's valuation. Follow a maximizing
child until a base rank is reached. Strict descent makes this finite. The
resulting sum has at most nu_gamma copies of v_p(S(gamma)) on each observed
plateau. The maximizing chain can depend on p; the visit bound holds for all
chains, so no common maximizing chain is needed. Therefore, simultaneously
for every 1<=n<=N,

```
B_n divides Q_new(N) = product_(gamma<=floor(N/A)) S(gamma)^nu_gamma.
```

Moreover

```
Q_new(N) divides Q_old(N) = product_(gamma<=floor(N/A)) S(gamma)^tau.
```

Every exponent is lower. Divisibility is strict whenever at least one observed
plateau has S(gamma)>1. Replacing tau by nu_gamma also tightens the explicit
bit envelope to `log2 B_n <= sum_gamma nu_gamma*log2 S(gamma)`; this does not
assert a lower asymptotic degree or change the width sequence.

The argument is also a self-contained lemma for any integer width recurrence
with the same constant-plateau census, complement steps, below-plateau exits
and unit base widths. Physical native semantics are not needed for that lemma.

## 4. A sharp first-plateau instance

Take targets (2,3), one paid rank-1 site, A>=3 and A<=N<2A. Then gamma=1,
gamma_next=2, t_2=t_3=1, S=2, delta=2 and the individual exit is e=1.
The new divisor is

```
Q_new(N) = 2^(1+floor((N-A)/2)),
Q_old(N) = 2^A.
```

Jerry Chen's #7424 already gives the width formula
`B_n=2^(1+floor((n-A)/2))` on this plateau. We cite that formula as a premise;
it is not the new result. Our divisor attains it exactly at N, so its exponent
cannot be decreased even by one. At A=64, N=127 the upper divisor changes
from 2^64 to the attained 2^32. The source's quadratic explicit-output
obstruction still applies; the smaller divisor does not remove it.

The uniform A-1 visit constant is sharp as well: two target roles of rank A
and one paid rank-1 site have their first plateau [A,A^2-1], with delta=A,
S=2 and exactly A-1 visits. This follows directly by taking successive
rank-A complements. No physical supplier for either toy rule is asserted.

## 5. Evidence and limits

The standard-library checker expands small productive words and paid paths,
then constructs only the exact width recurrence and directed child graph. It
checks the new divisor, its divisibility into the old divisor, actual longest
plateau visits by a separate graph dynamic program, and attaining truncated
plateaus. It imports no predecessor program and runs no predecessor suite.
Finite enumeration corroborates the new theorem; it is not an all-rank proof.

The result assumes the stated separated numerical compiler and its credited
flow. It supplies no actual selected manifest, complete instruction stream,
new batching policy, native realization, owner erasure, precision/tape bound,
analytic recovery or multiplication theorem. All five selected assumptions
remain. Independent human and formal proof-kernel review are unclaimed.
131 changes: 131 additions & 0 deletions research/additive-plateau-width/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,131 @@
# A sharper plateau divisor for chronological widths

**Scoped written proof with exact finite corroboration. No new κ.**
This contribution was produced by Nick Petalas.

For the separated fixed-rule numerical compiler of Jerry Chen / CubeJerry's
[#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424), replace its
common plateau exponent `tau=A*ceil(log2 k_min)` by

```
nu_gamma = 1 + floor((min(N,A*gamma_next-1)-A*gamma)/delta_gamma),
delta_gamma = smallest positive fresh-source rank on the plateau.

B_n divides product_gamma S(gamma)^nu_gamma, for every 1 <= n <= N.
```

Every new exponent is at most `A-1`, strictly below the previous `tau`.
The new divisor divides the old one, strictly whenever an observed plateau
has source count greater than one. It also gives a smaller explicit bit
upper bound. It changes neither the width sequence nor its proved
asymptotic degree. [PROOF.md](PROOF.md) states all hypotheses and proves
that the visit exponent is the exact maximum on the numerical child graph.

The reason is specific: every paid exit leaves its parent's plateau, while
every complement step inside it subtracts at least `delta_gamma`. Applying
that count to every prime-valuation chain proves the divisor, including
primes absent from the rank alphabet.

For targets `(2,3)`, one paid rank-1 site, `A=64` and `N=127`, the upper
divisor decreases from `2^64` to `2^32`. The new divisor attains the width
already established by #7424. That width formula is credited prior work;
the new result is the general divisor refinement. No physical supplier for
this toy rule is asserted.

## Exact evidence

The independently written standard-library checker imports no predecessor
program. It constructs 670 distinct bounded rule/maximum fixtures, totaling
11,926 width rows and 851 plateau rows. All 851 literal graph maxima equal
the new visit bound. The divisor decreases strictly on 448 fixtures; 222
have only base ranks. A further 294 first-plateau/truncation fixtures attain
the divisor exactly. Sixteen domain and semantic controls pass, including
lowering the exponent, dropping its final `+1`, allowing a same-plateau exit,
and pooling repeated chronological cuts.

Normal and optimized runs print identical computed results and fixture digest:

```
PASS_ADDITIVE_PLATEAU_WIDTH
computed_library_sha256=39175e152722a32239563041f1ee5c4669c8aca9b5212d3bc96a0ccb98dd8365
```

Counts refer to the stated finite fixtures. The universal statement rests
on the written proof and the cited numerical-flow premises. No predecessor
scientific suite or selected cold replay was run.

## Reproduce

From the repository root, with CPython 3.12 and its standard library:

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/additive-plateau-width/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/additive-plateau-width/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/additive-plateau-width
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/additive-plateau-width --check-source-history --check-modes
```

Substitute another CPython 3.12 path on another machine. The two registered
commands have 120-second timeouts. Direct verification writes nothing.
Adding `--record /absolute/external/new.json` generates a receipt with the
computed results, interpreter version and SHA256 hashes of all seven package
files. It refuses existing paths. A receipt is never hand-written.

[SOURCES.json](SOURCES.json) pins main's historical task/selected/width documents
as provenance. It separately identifies the exact public #7424 proof and its
SHA256 as cited mathematical provenance. No external executable/data inputs,
network access or unmerged Git objects are needed by the direct verifier.
The citation hash is not a claim of runtime authentication or theorem review.

## Limits and implementation bounds

The theorem concerns the exact least-replication recurrence for finite fixed
separated histograms with `r_max<k_min` and `m<=A`. It supplies no evaluated
selected manifest or new batching policy. Native semantics, owned erasure,
complete instruction generation, tape/precision and analytic recovery remain
separate. All five selected assumptions remain. No complete multiplication
theorem, physical runtime/memory gain or frontier change follows.
Independent human and formal proof-kernel review are unclaimed.

The executable checker restricts `A,N<=256` and each explicit role list to
four entries. All loops have finite bounds; word/path depths are at most
eight. Each census has at most 131,072 visited units and 65,536 exits. It
retains fewer than 17 million child entries in the most permissive allowed
case; actual fixtures are smaller. Python's managed allocation is a stated
Power of Ten rule-3 deviation: the enforced caps bound collections, and no
persistent process or cache is retained. A fixed-capacity implementation
would be needed before increasing these limits. Functions stay below 60
physical lines, checks use explicit exceptions under `-O`, and warning-strict
source compilation and execution are the applicable diagnostics. No external
linter or type checker is required by this standard-library package.
The invalid-input table has eleven fixed local callbacks, a bounded rule-9
deviation used only to exercise rejection paths. They run synchronously and
hold no external state; direct dispatch would replace them before that table
accepted externally supplied cases.

## Open next questions

1. Retain actual source multiplicities and gcd discounts for one evaluated
selected histogram. Start from its exact chronological source manifest
and derive a prime-valuation bound. That manifest and analysis are absent
here; a smaller visit count does not prove additional cancellation.
2. Specify a compact width representation and its exact divisibility-query
contract when A varies. The cited quadratic explicit-output obstruction
survives this refinement; changing the representation needs a new proof.

## Credit and scope

Jerry Chen / CubeJerry #7424 at
`d622d8c62defa9defeb95741e88b33a120044866` supplies the independent-ambient
recurrence and explicit open question about ambient constants; #7345 supplies
its quantitative library framework. codyw912 #4638 supplies the original
plateau-product divisor. Mihir Srivastava #4507/#5071 supplies chronological
gcd/LCM batching; zxv and Jacob Alan Sussman supply the compiler/flow, with
Ryanson Jonathan, Cinna Davis and the retained native lineage credited by
those sources. Their results are premises, not audit deliverables.

The new minimum-decrement argument, divisor proof and checker were produced
by Nick Petalas. New work is Apache-2.0. The formal-interface-lemma card is
explicitly changed to this written compiler-size side result. The selected
orientation passed at main `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision 8, selected #7000. [Advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19571833).
34 changes: 34 additions & 0 deletions research/additive-plateau-width/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
{
"schema_version": 1,
"base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
"sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
"sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
},
{
"path": "research/chronological-width-bound/README.md",
"usage": "provenance",
"git_blob": "7548fd2060e41cf5b58485126d14b4dec936406a",
"sha256": "0a255788cd9b462c4cbef39721ce42d129878bf564fc08be33752ca84530e38d"
}
],
"external_provenance": [
{
"pr": 7424,
"author": "Jerry Chen / CubeJerry",
"head": "d622d8c62defa9defeb95741e88b33a120044866",
"url": "https://github.com/CubeJerry/integer-mult-bounds/blob/d622d8c62defa9defeb95741e88b33a120044866/research/ambient-rank-library/PROOF.md",
"sha256": "a7d75efc8f4c38ca231324f99ce92b0d45df91cbd5ef89c93224700bf740b0c7",
"usage": "Cited mathematical recurrence and flow properties; no runtime import, checkout or replay dependency."
}
]
}
Loading
Loading