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
151 changes: 151 additions & 0 deletions research/split-only-tensor-feasibility/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,151 @@
# Exact feasibility of tensoring with capped splitting

This scoped proof was produced by Nick Petalas. Apache-2.0.

Fix a real exponent 0<t<1. A finite nonempty paid multiset P consists of
positive integer ranks p, with repetitions counted. A finite nonempty target
multiset T is defined similarly. Write P_s=sum_(p in P) p^s and
T_s=sum_(r in T) r^s. Fix a positive integer cap base c. At tensor power v>=1,
each ordered v-tuple of original paid jobs supplies one job of rank equal to
the product of its ranks. These jobs remain distinct even when their ranks
coincide. Partition each such job separately into positive integer pieces
of rank at most J=c^v. Charge the sum of the pieces' t-powers. Targets stay
unchanged, so their tensor t-moment is T_t^v. There is no target completion.

## Theorem

Let S_v be the least possible total paid charge over these capped partitions.
Put A=P_t and D=P_1 c^(t-1). Then

```text
max(A^v,D^v) <= S_v <= A^v+D^v.
lim_(v->infinity) S_v^(1/v) = max(A,D).

There is a v>=1 with S_v<T_t^v
if and only if max(P_t,P_1 c^(t-1))<T_t.
```

If a=max(A,D)/T_t<1, every positive integer v with 2a^v<1 works.
Thus the criterion is constructive. Equality in either necessary inequality
excludes a strict advantage at every power. Alternative partitions, irregular
piece sizes and more pieces cannot evade that conclusion in this model.

## One job

For positive integers R,J, write R=qJ+r with 0<=r<J. The least partition
charge is

```text
g_t(R,J)=q J^t+r^t, with 0^t=0.
```

If a partition has two pieces 0<a<=b<J, move mass from a to b until a
reaches zero or b reaches J. For 0<=x<=min(a,J-b), the function
(a-x)^t+(b+x)^t is nonincreasing. In the interior its derivative is
t((b+x)^(t-1)-(a-x)^(t-1))<=0, and continuity covers the endpoints.
Delete a zero piece. Each operation reduces the number of pieces strictly
between zero and J, so finitely many operations leave only full J-pieces
and at most one remainder. Their sum determines q and r uniquely. This
proves the minimum, including partitions with arbitrarily many pieces.

For any capped partition R=sum_i r_i, subadditivity and the cap give

```text
sum_i r_i^t >= R^t,
sum_i r_i^t >= sum_i r_i J^(t-1)=R J^(t-1).
```

Subadditivity follows from (a+b)^t<=a^t+b^t for nonnegative a,b.
For b>0 the derivative of (a+b)^t-a^t is nonpositive as a increases,
so the difference is at most b^t. Induction covers every finite partition.
The second inequality uses t-1<0 and 0<r_i<=J.

The quotient-and-remainder partition also gives the upper bound

```text
g_t(R,J)=q J^t+r^t <= R J^(t-1)+R^t.
```

Indeed qJ<=R and r<=R. These bounds apply when R<=J too. There is no
restriction to oversized jobs and no missing small-job term.

## Tensor sum and the strict boundary

Sum the two lower bounds separately over the ordered tensor jobs. Finite
distributivity gives sum R^t=P_t^v and sum R=P_1^v. Since J=c^v, their
two lower bounds are A^v and D^v. The same sums applied to the constructive
upper bound give A^v+D^v. Consequently

```text
max(A,D) <= S_v^(1/v) <= 2^(1/v) max(A,D).
```

The squeeze proves the limit. If S_v<T_t^v at any power, each lower bound
is strictly below T_t^v, so A<T_t and D<T_t. Conversely, if both are
strict, choose v with 2(max(A,D)/T_t)^v<1 and apply the upper bound. This
proves existence and the asserted uniform sufficient powers. If either
A>=T_t or D>=T_t, the corresponding lower bound excludes every power.
In particular, a limiting equality cannot be treated as a passing endpoint.

## Padding-free separation

Let k be the least original target rank. If 1<=c<k, every resulting paid
piece has rank at most c^v, whereas every tensor target has rank at least
k^v. Thus the same construction has strict paid/target separation. When
k>=2, a legal integer cap exists with a strict moment advantage at some
power exactly when

```text
P_t<T_t and P_1 (k-1)^(t-1)<T_t.
```

Necessity uses monotonicity in c and c<=k-1. Sufficiency chooses c=k-1
and applies the theorem. If k=1 no positive integer c<k exists. This is
only a criterion for this padding-free operation. Compilers that complete
targets or change the producer/consumer require a different criterion.

## Exact discriminating examples

All examples use t=1/2 and are abstract inventories, without claimed native
realizations.

* T={4,4,4}, P={9}. There is raw moment surplus 6-3=3 and rank-one
surplus 12-9=3. At cap base c=2, D=9/sqrt(2)>6, so no tensor power
works, even with arbitrary capped partitions. At c=3, D=3sqrt(3)<6
and P_t=3<6. All targets exceed the cap base in both cases.
* T={81}, P={17}, c=4. The first power costs 4sqrt(4)+sqrt(1)=9,
exactly the target charge. At power two the cost is
18sqrt(16)+sqrt(1)=73<81. The criterion predicts existence, rather
than a win at every positive power. Dropping the first remainder would
falsely claim a first-power win of 8<9.
* T={16}, P={4,4}, c=9. A=T_t=4 and all jobs are unsplit, so S_v=4^v.
T={64}, P={16}, c=4 instead has A=4<T_t=8 and D=T_t=8; full blocks
give S_v=8^v. These distinguish the two equality obstructions.

## Relation to prior work and scope

zxv's PR4433 supplies the retained tensor splitting framework and sufficient
higher-moment paid-tail estimates. Cinna Davis's PR4412/4414/4416 supplies
chronological tensor product and completion; Jacob Alan Sussman supplies
the integer compiler. They retain all native, helper, controller, precision
and outer credit. None of those scientific programs is replayed here.

Nick Petalas's PR4832 and PR6390 optimize universal one-job upper-bound
coefficients; PR7135 concerns the distinct net splitting tax. Those results
are background, not premises of this proof. This theorem uses the elementary
two-sided bounds above to give an exact any-power feasibility criterion and
exponential rate for a fixed cap. It neither sharpens their coefficients
nor extends their optimizers to another exponent or target.

Concavity, finite products and the squeeze argument are classical. No global
literature-priority claim is made for those ingredients. The contribution
is this exact tensor feasibility screen and its strict-boundary application.

Only disjoint partitions within each original job are allowed. Cross-job
merging, target completion, additional charges, altered target credits and
physical interfaces require fresh arguments. This proof establishes no
native implementation, chronology/ownership admission, uniform compiler,
precision/tape bill, new kappa or complete multiplication theorem. All five
selected framework assumptions remain. Independent human and formal
proof-kernel review are unclaimed. The finite verifier corroborates this
written proof; it does not supply its all-real or all-power quantifiers.
144 changes: 144 additions & 0 deletions research/split-only-tensor-feasibility/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
# Exact tensor feasibility under capped splitting

This contribution was produced by Nick Petalas. Apache-2.0.

Claim type: scoped written proof with exact finite corroboration. For any
fixed finite positive-integer paid and target inventories, real 0<t<1
and positive integer cap base c, tensoring and disjoint capped splitting
can beat the unchanged target moment at some positive tensor power exactly
when

```text
max(P_t, P_1 c^(t-1)) < T_t.
```

Here P_s and T_s are the inventories' power sums. At power v the cap is c^v.
The optimal paid charge S_v has the exact exponential rate

```text
lim S_v^(1/v) = max(P_t, P_1 c^(t-1)).
```

Equality in either inequality excludes a strict gain at every power. This
can reject a futile cap choice before searching tensor powers or tail
parameters. Every partition of each job into capped integer pieces is
covered. Cross-job merging and target completion are outside this model.
No new kappa, native supplier or selected-frontier change is claimed.

[PROOF.md](PROOF.md) gives the all-real, all-power argument. Its elementary
two-sided bound is

```text
max(P_t^v, (P_1 c^(t-1))^v) <= S_v
<= P_t^v + (P_1 c^(t-1))^v.
```

If k>=2 is the least target rank, some legal integer cap c<k gives both
separation and a moment gain at some power exactly when P_t<T_t and
P_1 (k-1)^(t-1)<T_t. This is an accounting criterion for padding-free
splitting. Native tensor closure and a full compiler remain separate.

## Discriminating examples

At t=1/2, the abstract inventory T={4,4,4}, P={9} has both raw moment
surplus and rank-one surplus equal to three. Cap base two still fails at
every power, because 9/sqrt(2)>6. Cap base three passes the criterion.

For T={81}, P={17}, c=4, the first-power split charge is exactly nine,
equal to the target. At the second power it is 73<81. This distinguishes
eventual feasibility from an immediate win. The verifier also treats both
types of equality obstruction. None of these inventories is asserted to
have a native realization.

## Reproduce

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

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/split-only-tensor-feasibility/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/split-only-tensor-feasibility/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/split-only-tensor-feasibility
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/split-only-tensor-feasibility --check-source-history
```

Other machines may substitute any CPython 3.12 path. The direct verifier
writes nothing, imports no predecessor executable and works without Git or
network access. It prints generated JSON bound to all six package-file
hashes, followed by `PASS_SPLIT_ONLY_TENSOR_FEASIBILITY`. No receipt is
handwritten or used as an answer oracle. The metadata and committed-byte
checks separately authenticate provenance and publication bytes.

The finite replay checks 18,432 one-job splits at six rational exponents;
256 exact dynamic-programming partition optima; 468 tensor histograms;
and 2,496 profile/cap/target-moment decisions. The 1,767 passing decisions
each have an actually evaluated sufficient-power witness, at powers up
to twenty. Independent literal enumeration checks 3,072 ordered job tuples
and 176 explicit partition contexts. Thirty-nine boundary checks and
fifteen invalid-input rejections protect remainder costs and strictness.
Rational root brackets use integer arithmetic; comparisons fail if their
intervals do not separate. The universal theorem rests on the written proof.

## Sources and scope

Base canonical main is `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision eight. The selected record is #7000 and kappa=0.00363005817.
The selected binding-only orientation passed; it is not a supplier replay.
[SOURCES.json](SOURCES.json) pins historical provenance, including zxv's
PR4433 framework document. There are no external scientific runtime inputs.

Credit zxv's [PR4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433)
for the tensor paid-splitting framework; Cinna Davis's PR4412/4414/4416
for chronological product and completion; and Jacob Alan Sussman for the
integer compiler. Their native, helper, controller and outer lineage retains
its credit. The new step is the exact exponential rate and any-power
feasibility criterion. Concavity and the product/squeeze arguments are
classical; no global literature-priority claim is made for those ingredients.

Nick Petalas's PR4832/6390 one-job coefficient results and PR7135 net-tax
optimizer are background, not premises or main steps of this proof. This
result does not change their optimizers or reuse their constructions. It
changes the independent-moment card from audit to an original quantified
accounting theorem, as recorded in [TASK.json](TASK.json).

The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19595330)
states the same scope. Entry checks covered live open/own PRs, the handoff
and active Discussions, all tracked main README/proof literal searches,
and merged-PR searches. The cached helper reported 826 open PRs and 7,445
Discussion records with complete pagination. Its sparse local coverage
was only 228 of 10,178 notes, supplemented by direct Git searches.
Arbitrary historical diffs and unpublished work remain outside coverage.

This is not a complete signed invoice when completion, target debits or
other costs apply. Physical arbitrary-input realization, ownership,
restoration, chronological native closure, stock, precision, tape and outer
recovery remain unproved and unpriced here. All five selected assumptions
remain. No predecessor scientific verifier, selected cold replay, Lean or
Docker run was performed. Independent human and formal proof-kernel review
are unclaimed.

## Open next questions

1. Can one changed native inventory use this screen to avoid target
completion? Start with its complete tensor/splitting contract and the
two moments at c=min(target)-1. Native realization and full physical
costs remain blockers.
2. What is the exact feasibility criterion when same-owner target completion
is also allowed? Start with both completed inventories at one fixed
floor base. A joint two-sided estimate is missing; this result cannot
discard the completion charge.

## Verifier constraints

The verifier has no recursion, subprocesses, network access, writes or
generated code. Every function is under sixty lines. Integer-root bisection
has a bit-length iteration cap. Scientific fixture loops have explicit
finite domains; tensor powers are capped at 64, profile supports at three,
histograms at 5,000 entries and power inputs at 1,024 bits. Source reads cover
six files capped at 256 KiB each. All guards remain active under optimization.

Power of Ten rule 3 has a managed-runtime deviation. CPython allocates
integers, fractions and bounded containers dynamically. The fixture caps
bound live algorithmic state; allocator internals are not instrumented.
Warning-strict normal and optimized runs and AST/function-size inspection
are the available diagnostics. No repository-wide static analyzer or
fixed-allocation implementation is claimed.
24 changes: 24 additions & 0 deletions research/split-only-tensor-feasibility/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,24 @@
{
"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/higher-moment-strictification/README.md",
"usage": "provenance",
"git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3",
"sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d"
}
]
}
Loading
Loading