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
156 changes: 156 additions & 0 deletions research/binomial-source-floor/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,156 @@
# Sharp source floor from five inventory summaries

This is a scoped written proof, produced by Nick Petalas. Apache-2.0.
It uses Ali Romman's all-height source telescope from
[PR #5318](https://github.com/CrocSwap/integer-mult-bounds/pull/5318) as a
premise. The binomial counting identity and monotone comparison are elementary;
no literature-wide priority for those methods is claimed.

## Contract and credited premise

Treat each productive or paid position as a separate token, including repeated
ranks. Let productive ranks have exact minimum L and maximum M, with
2 <= L < M. There are W productive tokens, exactly t of rank M, where
1 <= t < W. There are Q paid tokens, each with positive integer rank below L.
Assume Q >= W. For an integer cap c >= 1, let g be the unique nonnegative
integer satisfying L^g <= c < L^(g+1).

For d in 0,...,g, let F_d(c) count words consisting of d ordered paid tokens
and g-d ordered productive tokens whose rank product is at most c.
The paid and productive positions are distinguished. There is no factor
binomial(g,d) choosing their interleaving. The chronological source model
and its Pascal matching are exactly those of the credited predecessor.

Write D_d(c) = Q^d W^(g-d) - F_d(c). The predecessor proves

```text
S(c) = W^(g+1) + (Q-W) sum_(d=0,...,g-1) D_d(c). (1)
```

This note neither replays that package nor claims a new source census.
The new question is the sharp lower envelope of (1) with only
L, M, W, Q, t fixed.

## Pointwise theorem

Define

```text
B_d(c) = Q^d sum_(k=0,...,g-d)
binomial(g-d,k) t^k (W-t)^(g-d-k)
[L^(g-d-k) M^k > c].

E(c) = W^(g+1) + (Q-W) sum_(d=0,...,g-1) B_d(c). (2)
```

Square brackets denote an indicator. Then S(c) >= E(c). Moreover E(c)
is the exact minimum of S(c) over all inventories with these five summaries.
The empty sum gives E(c)=W when g=0.

To prove the inequality, preserve token identities and replace every
nonmaximum productive rank by L and every paid rank by 1. Preserve all t
maximum-rank tokens at M. Every word's rank product weakly decreases.
Consequently each word still above c after replacement was above c before
replacement, so D_d(c) >= B_d(c).

For the replaced word, choosing its k maximum-rank productive positions
and their identities gives precisely the summand in (2). All Q^d paid
token words have the same replaced rank 1, but remain distinct words.
Multiplying by the nonnegative Q-W in (1) proves the inequality.

The replaced inventory itself has the required exact minimum, maximum,
counts and separation. Its productive histogram is
{L: W-t, M: t}; its paid histogram is {1: Q}. Every preceding inequality
is equality for that inventory, proving sharpness. This is sharpness over
the summary-data class, not attainment by a native or physical compiler.

The sign condition matters. For example, take L=2, M=4, W=3, t=1, Q=1
and c=4. The collapsed inventory has 17 sources, whereas productive ranks
(2,3,4) and the same single rank-one paid token have 11. Thus (2) is not
a lower bound if Q<W. If Q=W, (1) makes every source count W^(g+1).

## Sharp bound throughout a height slab

Within a fixed height g, the indicators in (2) decrease as c increases.
Therefore the best uniform floor from these summaries on the entire slab
L^g <= c < L^(g+1) is E(L^(g+1)-1). This is attained by the collapsed
inventory at that integer cap. At the upper cap, the indicator is exactly

```text
L^(g-d-k) M^k >= L^(g+1). (3)
```

The distinction between >c and >=L^(g+1) is the integer boundary, not
a relaxation. In particular, rank product equal to c is eligible and
must not be charged as a deficit.

## Power-1024 application

The following are cited source facts from PR #5318 and the retained
[#4470 invoice](../joint-helper-lattice/RESULT.json), not results
reverified here. Under that unchanged historical product, completion and
split rule,

```text
v = 1024,
L = 21^v, M = 145^v, W = 10928^v, t = 224^v,
Q >= Q0 = 64620^v > W, and every paid rank is below L.
```

Exactly t maximum-rank tokens remain because a product of v productive
ranks equals 145^v precisely when every factor is one of the 224 rank-145
tokens. The completion floor is below this maximum. The inherited lower
bound Q>=Q0 includes the fact that each raw paid call yields at least one
positive split call; completion may add more.

The exact small integer comparisons are

```text
21 < 145 < 21^2, 145^2 > 21^3.
```

At g=1 and the slab's upper cap, even M is eligible, so the best uniform
summary-data floor remains W^2. At g=2, exactly the pair of maximum-rank
productive tokens is ineligible in the collapsed depth-zero word. A word
with only one maximum has product L M < L^3. At depth one, even M < L^3
is eligible. Equations (2) and (3) therefore give the exact summary minimum

```text
min_(L^2 <= c < L^3) S(c) = W^3 + (Q-W)t^2. (4)
```

The minimum in (4) ranges over inventories with the declared summaries
as well as caps. For the actual historical inventory it is a lower bound,
not an asserted exact source count. Substituting Q>=Q0 gives the new
explicit correction

```text
S(c) >= 10928^(3072)
+ (64620^1024 - 10928^1024) * 224^2048
> W^3.
```

More generally, for every g>=2 and every cap in its height slab, any
depth-zero word with at least two maximum-rank tokens is ineligible:
L^(g-k)M^k >= L^(g-2)M^2 > L^(g+1) > c for k>=2.
Counting just these words in (1) proves

```text
S(c) >= W^(g+1) + (Q0-W)
* (W^g - (W-t)^g - g*t*(W-t)^(g-1))
> W^(g+1). (5)
```

Equation (2) can be stronger because it retains other depths and threshold
terms. Formula (5) is a simple explicit correction valid throughout every
height slab g>=2 of the actual power-1024 model. The all-height quantifier
is proved above; the executable does not enumerate its enormous heights.

## Scope

This improves a mathematical source-count lower bound for an unchanged
historical nested compiler. It supplies neither a higher accumulated K/N
coefficient nor a smaller compiler width. The selected #7000 construction,
kappa, physical stock, routing, ownership, native realization, precision/tape,
all-size admission and analytic recovery are unchanged. No complete
multiplication theorem or independent human or proof-kernel review is claimed.
134 changes: 134 additions & 0 deletions research/binomial-source-floor/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,134 @@
# Sharp binomial source floors for separated inventories

Scoped written proof with exact finite corroboration, produced by Nick Petalas.
No new kappa. Apache-2.0.

The all-height floor `S(c) >= W^(g+1)` from Ali Romman's
[PR #5318](https://github.com/CrocSwap/integer-mult-bounds/pull/5318) now has
a sharp summary-data refinement. Fix the productive minimum L, maximum M,
maximum-rank multiplicity t, productive count W and paid count Q>=W, with
all positive paid ranks below L. The exact minimum source count among those
inventories is a finite binomial-tail expression, attained by productive
ranks `{L:W-t,M:t}` and paid ranks `{1:Q}`.

For `L^g <= c < L^(g+1)`, the new floor is

```text
W^(g+1) + (Q-W) sum_(d=0,...,g-1) Q^d
* sum_(k=0,...,g-d) binomial(g-d,k) t^k (W-t)^(g-d-k)
[L^(g-d-k) M^k > c].
```

[PROOF.md](PROOF.md) gives the tokenwise comparison and sharpness proof.
The entire height slab has its sharp uniform floor at `c=L^(g+1)-1`.
This is an exact extremal result for an abstract inventory class, not an
exact count or an attaining implementation for a selected supplier.

For the unchanged historical #4470 rule at product power 1024, the new
first strict uniform correction occurs at height two:

```text
L=21^1024, M=145^1024, W=10928^1024, t=224^1024,
Q >= Q0=64620^1024,

S(c) >= W^3 + (Q0-W)t^2 > W^3 when L^2 <= c < L^3.
```

For every larger height g>=2, a simple uniform correction is

```text
S(c) >= W^(g+1) + (Q0-W)
* (W^g - (W-t)^g - g*t*(W-t)^(g-1)) > W^(g+1).
```

This quantifies part of #5318's explicitly open top-slab deficit question
at the actual product power. The correction is small. No improved accumulated
K/N coefficient, reduced compiler width or physical saving is claimed.
The selected #7000 frontier remains unchanged.

## 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 -W error -B research/binomial-source-floor/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/binomial-source-floor/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/binomial-source-floor
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/binomial-source-floor --check-source-history
```

On another machine, replace the absolute interpreter path with its CPython
3.12 executable. The direct marker is `PASS_BINOMIAL_SOURCE_FLOOR no_new_kappa`.
The checker prints a generated receipt with package and cited-input hashes.
`--receipt /absolute/path/outside/the/checkout/receipt.json` also saves it.
It creates no files by default.

The independent root/nonroot slot enumerator passes 2,250 inventory/cap cases,
including 459 strict comparisons. A product-histogram implementation passes
1,640 attaining cases through height six. Eight semantic checks cover the
strict cutoff, height change, exact first correction and the Q<W reversal;
eight invalid summary inputs are rejected. The power-1024 application checks
the new threshold inequalities and correction directly with exact integers.
The correction has 32,353 bits; its decimal-byte SHA256 is
`cc8d4edeefa3ba49f597543ea6d0c344fa6cbbd630510204757e881b0478f3ae`.

These checks test the new extremal theorem and its application. No predecessor
executable, predecessor receipt or selected supplier replay is run. The
predecessor census, power-1024 invoice and separation contract are cited
premises. [SOURCES.json](SOURCES.json) pins their exact retained source bytes;
[TASK.json](TASK.json) records the scope change and next questions.

## Implementation limits

The theorem permits every finite height and every positive integer inventory
in its stated domain. The reference function in [floor.py](floor.py) is
deliberately bounded to L<=16, M<=32, W<=Q<=8 and heights at most six.
The fixed power-1024 application is checked separately, without expanding
its inventory or the actual compiler's large heights.

The code has no recursion or dynamic dispatch. Managed-runtime allocations
are a Power of Ten deviation; the small reference domains bound every loop
and live product histogram. Functions stay below sixty lines. Validation
uses explicit exceptions and survives `-O`. The registered commands enable
warning-strict normal and optimized Python checks. No native compiler,
formal prover, physical tape implementation, timing speedup or broad replay
is part of the claim.

## Credit and overlap

Ali Romman / aliromman #5318 supplies the exact all-height telescope and
the open quantitative-deficit question. JoyboyBrian #5067 supplies the
source census; zxv #4436 supplies the nested compiler, retaining Jacob Alan
Sussman's multinomial lockstep credit. Cinna Davis and zxv #4470 supply the
historical invoice and product/completion/splitting lineage, whose original
notices remain unchanged. Unpaidmoon #5273 supplies the height-one identity.
Nick Petalas #5109's upper coefficient is related background and is not
used in the proof. The binomial count is classical. Only the sharp five-summary
minimum and its explicit deficit application are claimed here.

The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19595351)
was posted after checking live claims, open PR bodies and main. The baseline
is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`.
The search covered 826 open PRs, 7,445 Discussion records and 10,178 local
README/TASK records, with complete reported pagination and note inventory.
Separate merged-work and recent-account source searches found no conflicting
target. The closed-PR bulk refresh timed out; targeted live merged searches
and the main inventory supplement it. No search certifies novelty or sees
unpublished work.

## Open next questions

- Can the complete productive histogram yield a quantitatively larger
accumulated K/N lower coefficient? Start by retaining a second productive
rank class in the deficit count and proving a finite-height bound for the
same historical completion rule. The present summary minimum alone does
not establish a better coefficient.
- Does a current physical compiler expose this exact separated-source model
with a useful complete stock and routing bill? Start with one source-pinned
caller and its owned lifetimes. The historical count theorem supplies no
physical implementation or supplier admission.

Native all-column operators, physical stock/ownership/routing, precision/tape,
uniform caller closure and analytic recovery remain unrun. This is neither
a finite certificate of the current supplier nor a complete multiplication
theorem. Independent human and formal proof-kernel review are unclaimed.
30 changes: 30 additions & 0 deletions research/binomial-source-floor/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,30 @@
{
"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/joint-helper-lattice/RESULT.json",
"usage": "input",
"git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596",
"sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21"
},
{
"path": "research/separated-source-telescope/README.md",
"usage": "input",
"git_blob": "cd2b4ec1d61c4579b9eb913c264c61845a28316e",
"sha256": "c8208fded3483c9719e133c0ad685d52306a572cfd7178afb01ec65c78bf1a06"
}
]
}
Loading
Loading