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
149 changes: 149 additions & 0 deletions research/shared-fourier-unit-input-error/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,149 @@
# Sharp unit-input error for a shared translated Fourier routine

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

## Contract and new result

Let G be a finite product of cyclic groups, N=|G|, with its standard
symmetric nondegenerate unit character pairing chi. Both Fourier signs have
the normalization

(F±u)(x) = (1/N) sum_y chi(x,y)^±1 u(y).

Fix a nonzero element b of order two. Put c(x)=chi(b,x), so c takes the
values +1 and -1 equally often. Let w be any unit-modulus complex function.
As in Nick Petalas's PR #6307, define

P_b f(x) = f(x+b),
B_w(u,v) = D_conj(w) P_b F+ [(D_w P_b F-u)(D_w P_b F-v)],
B(u,v) = (u*v)/N².

Convolution has no normalization. For a complex bilinear map T write

||T||_bil = sup { ||T(u,v)||_2 : ||u||_2=||v||_2=1 }.

The desired map has ||B||_bil=N^(-3/2). The relative unit-input error is

D(w) = ||B_w-B||_bil / ||B||_bil.

The new result, answering Open next question 2 of #6307, is

min_(|w|=1) D(w) = sqrt(2 - 8/(3 sqrt(3))). (1)

The inherited phase choice

w(x)=1/sqrt(3) - i sqrt(2/3)c(x) (2)

attains (1). Every pair of equal normalized characters attains the
unit-input supremum for (2). More generally the following exact formula
computes the unit-input norm for every phase function, without optimizing
over pairs of input vectors:

m = (1/N) sum_x c(x)w(x),
D(w)² = max_y {2 - 2 Re[conj(m)c(y)w(y)²]}. (3)

This statement is about absolute operator error divided by the norm of B.
It does not divide by ||B(u,v)|| at each input pair, which can be zero.

## A bilinear column-norm lemma

Let U,V be any unitary maps on C^N and M any complex matrix with N columns.
For T(u,v)=M[(Uu) pointwise (Vv)],

||T||_bil = max_j ||M e_j||_2. (4)

Indeed, for unit u,v, Cauchy-Schwarz gives

sum_j |(Uu)_j(Vv)_j| <= ||Uu||_2 ||Vv||_2 = 1.

The triangle inequality then bounds ||T(u,v)|| by the right side of (4).
If j maximizes it, choose u=U*e_j and v=V*e_j. Both are unit vectors,
their transformed pointwise product is e_j, and equality holds. This
argument works over complex inputs and for rectangular M as well.

The inequalities and the extremizing construction are classical elementary
norm facts. The contribution is their exact application at this normalized,
shared three-pass Fourier boundary and the resulting sharp minimax theorem.

## Apply the lemma with every normalization retained

Write f=F-u and g=F-v. Then sqrt(N)F- is unitary, and the difference is

(B_w-B)(u,v)=M(f pointwise g),
M_(x,z) = [conj(w(x))w(z-b)² chi(x+b,z-b)-chi(x,z)]/N.

The maps multiplying u and v each supply another factor 1/sqrt(N).
Equation (4) therefore gives

||B_w-B||_bil = (1/N) max_z ||M e_z||_2. (5)

For the desired map alone M=F+, whose columns all have norm 1/sqrt(N).
This proves ||B||_bil=N^(-3/2), including attainment.

Put y=z-b. The ratio of the implemented and desired coefficients in
column z is

rho(x,y)=conj(w(x))w(y)² c(x)c(y).

Here chi(x+b,y)/chi(x,y+b)=c(y)/c(x)=c(y)c(x), using that b has order two.
Every desired coefficient has modulus 1/N. Squaring (5) and dividing by
||B||_bil² gives

D(w)² = max_y (1/N) sum_x |rho(x,y)-1|².

All rho have modulus one. Their average over x is
conj(m)c(y)w(y)². Expanding |rho-1|² proves (3).

For any maximizing y, z=y+b and the explicit unit inputs are

u(x)=v(x)=chi(x,z)/sqrt(N).

Fourier orthogonality gives F-u=F-v=e_z/sqrt(N). They attain the column
in (5), so the upper bound is an attained supremum, not a relaxation.

## Sharp minimization using the credited predecessor inequality

PR #6307 proves, for every unit phase w in this same contract, that

E(w)² = 2 - 2 Re[conj(m)n] >= 2 - 8/(3 sqrt(3)),
n=(1/N)sum_y c(y)w(y)².

Its E is the relative coefficient Frobenius error N||B_w-B||_F.
The predecessor scalar moment inequality and its lower bound are cited
premises here. They are not re-proved or scientifically replayed.
Equation (3) immediately gives

D(w)² >= (1/N)sum_y {2-2 Re[conj(m)c(y)w(y)²]} = E(w)².

This proves the lower bound in (1) from the cited theorem.

For the inherited choice (2), put h=1/sqrt(3), r=sqrt(2/3). Then

m=-ir,
c(y)w(y)²=(h²-r²)c(y)-2ihr,
Re[conj(m)c(y)w(y)²]=2hr²=4/(3 sqrt(3)).

Thus every column in (3) has squared error 2-8/(3 sqrt(3)). This supplies
the new arbitrary-unit-input upper bound and proves (1). Every equal
character pair attains it, independently of chi(b,b) and N.
The optimal unnormalized absolute error is N^(-3/2) times (1).

## Scope and credit

Nick Petalas #6307 supplies the question, coefficient lower bound, scalar
inequality and phase choice. Hanson Sun / bbMisk #1477 supplies the exact
weighted-layout contract, extending Ross Richardson #940. Character
orthogonality, unitary Fourier normalization, Cauchy-Schwarz and elementary
induced-norm arguments retain their classical credit. Only the unit-input
norm formula, its extremizers and the sharp extension to the stronger input
contract are claimed here.

All finite products of cyclic groups and arbitrary unit complex phase functions are covered by
the written theorem under the stated order-two and shared-routine hypotheses.
The finite verifier uses only products of cyclic factors 2 and 4 of size at
most 16. Its exact arithmetic corroborates the new reduction and attaining
upper bound; it does not prove the universal theorem or audit the predecessor.
Other translation orders, physical phase preparation, rounding, routing,
restoration, compiler closure and the complete supplier bill are unsettled.
No new kappa, supplier admission or complete multiplication theorem follows.
Independent human and formal proof-kernel review are unclaimed.
139 changes: 139 additions & 0 deletions research/shared-fourier-unit-input-error/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,139 @@
# Sharp shared Fourier error on arbitrary unit inputs

This scoped written proof with exact finite corroboration was produced by
Nick Petalas. Apache-2.0. It answers Open next question 2 of
[PR #6307](https://github.com/CrocSwap/integer-mult-bounds/pull/6307).

For every finite product of cyclic groups and every nonzero order-two
translation, the shared phase-weighted three-pass Fourier routine has

min relative induced bilinear l2 error = sqrt(2 - 8/(3 sqrt(3))).

The inputs range over all pairs of complex unit-l2 vectors. Both Fourier
signs use 1/N, the desired output is convolution divided by N², and its
induced bilinear norm is N^(-3/2). Relative error divides the absolute
operator error by this norm, rather than by each input pair's output norm.
The latter can be zero.

The new exact formula for any unit phase function w is

c(x)=chi(b,x), m=average_x c(x)w(x),
D(w)²=max_y {2-2 Re[conj(m)c(y)w(y)²]}.

Equal normalized character inputs attain every column in this maximum.
The inherited choice `w=1/sqrt(3)-i sqrt(2/3)c` makes all columns equal
and attains the stated optimum. [PROOF.md](PROOF.md) retains every Fourier
normalization and proves the arbitrary-input upper bound. It cites #6307's
coefficient-error lower bound and scalar inequality as premises. Their proof,
phase choice and earlier basis-input result are predecessor work.

## Evidence

The standard-library verifier implements the three literal Fourier passes
and direct group-addition convolution in exact Q(sqrt(2),sqrt(3),i).
It does not import or run a predecessor module.

- All fourth-root phase assignments on Z/2, Z/4 and (Z/2)^2, at every
nonzero order-two translation, give 1,040 assignments. Each transformed
character input is checked directly against the new column formula.
- Eighteen minimizing fixtures on six group shapes of size 2 through 16
check column flatness and attainment. Together with the phase census,
this gives 1,058 assignments and 4,274 equal-character input pairs.
- Another 72 pairs use distinct characters and real or complex unit
superpositions. Their literal errors obey the new sharp upper bound.
- Ten controls cover omitted final conjugation, omitted final translation,
missing normalization, maximum versus mean, and six malformed domains
rejected for the exact expected reasons. In the maximum-versus-mean
fixture, squared coefficient error is 7/4 while squared unit-input error
is 5/2. Thus averaging columns would miss the new norm.

Every count is enumerated. The universal result is the written proof;
these finite checks corroborate its reduction and upper bound. Each run
prints a generated JSON receipt binding all six package files by SHA256.
Ordinary verification writes nothing. No hand-written receipt is retained.

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

Another CPython 3.12 path may replace the displayed local interpreter.
Expected markers are `PASS_SHARED_FOURIER_UNIT_INPUT_ERROR`,
`PASS_REGISTERED_RESEARCH_PACKAGE` and `PASS_RESEARCH_COMMIT_BYTES`.
Both registered checks have a 120-second timeout. Explicit guards remain
active under optimized Python. The direct verifier needs only these six
files and also works without Git; source-history checking needs full history.

## Scope, sources and credit

Base is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision 8. The selected source-binding orientation passed for #7000,
conditional kappa .00363005817. The catalogue still describes the older
#5599 assessment; it does not establish the current selected value.
The joint-query-controller card is explicitly changed to this analytic
side result in [TASK.json](TASK.json). It supplies an approximation boundary,
not a changed physical caller or a favorable complete recursive invoice.

[SOURCES.json](SOURCES.json) pins the card, selected record and predecessor
proof text as historical provenance. No predecessor bytes are runtime inputs.
Credit Nick Petalas #6307 for the question, scalar moment inequality,
coefficient lower bound and minimizing phases; Hanson Sun / bbMisk #1477
for the weighted-layout contract, extending Ross Richardson #940.
Character orthogonality, Cauchy-Schwarz, the triangle inequality and elementary
induced-norm arguments retain their classical status. The contribution is
the exact unit-input formula, explicit extremizers and sharp extension.

[Advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592047).
Live PRs, recent account work, active Discussions, reservations, main-tree
README terms and distinctive merged searches were checked. The overlap
snapshot covers 810 open PRs and 7,416 Discussion records with complete
remote pagination. Its sparse local-note search covers 215 of 10,178 notes.
This does not establish absence of unpublished or differently worded work.

Only the stated shared routine, complex l2 input norm and nonzero order-two
translation are covered. Other translations, physical phase preparation,
rounded arithmetic, routing, dirty restoration, storage, compiler closure,
analytic recovery and a complete supplier bill remain unsettled. The five
selected framework assumptions retain their status. No new kappa, supplier
admission, selected-frontier change or complete multiplication theorem is
claimed. Selected cold replay, predecessor scientific suites, Lean, Docker
and a literal physical caller were unrun. Independent human and formal
proof-kernel review are unclaimed.

## Open next questions

- Determine the sharp unit-input error at a translation of order three.
Begin with its column formula. A matching nonbinary phase inequality and
attaining construction are missing.
- Price an actual rounded caller using approximations to the attaining
phases. Begin with its grid and norm contract; charge coefficient
preparation, routing, restoration and the complete recursive invoice.

Structured relevance, first steps and blockers are in TASK.json. No further
question is reserved by this package.

## Verifier constraints

There is no recursion, subprocess, network, dynamic code execution, callback
dispatch or file-writing path. Functions are below sixty physical lines.
Group dimension is at most four, group size at most sixteen, field dimension
eight, and the largest phase loop has 4^4 assignments. Each literal Fourier
pass has at most 16² terms and each convolution at most 16² pairs. Comparisons
use at most four exact integer-square-root enclosures, through 256 bits, and
fail if they cannot separate a nonzero value. Six package reads are each
capped at 256 KiB plus one guard byte. Syntax inspection and warning-strict
normal/optimized execution provide the available Python diagnostics.

Power of Ten rule 3 deviation: CPython and Fraction allocate managed objects.
This fixed, one-shot census streams assignments, holds vectors of at most
sixteen eight-component field values and no result cache, and reads package
files one at a time under the stated cap. Dynamic allocation cannot be
disabled in this runtime. The finite domain, capacity rejection and both
registered runs are the compensating controls. A fixed-allocation native
implementation would need its own storage contract before integration.
36 changes: 36 additions & 0 deletions research/shared-fourier-unit-input-error/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,36 @@
{
"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/shared-fourier-translation-floor/README.md",
"usage": "provenance",
"git_blob": "d1ed80965d756b3cd568fa0f2b5c5863080c6659",
"sha256": "7b48f98e16de222060af66fdcc4ce42273268468eeeaa302fe713f0869f462d3"
},
{
"path": "research/shared-fourier-translation-floor/PROOF.md",
"usage": "provenance",
"git_blob": "acc9c3488da5400a05734d828f520bb38869dae7",
"sha256": "d8b456848f573de232822591e45e2b22720fdfa0236830495f5c0bfa631cf7bc"
},
{
"path": "research/weighted-fourier-layout/README.md",
"usage": "provenance",
"git_blob": "7cd23891f12ea1f054ed778289bc45a7e8fb622e",
"sha256": "676e107f9e312a36793ec87ca9eec3df3c8764c71268153055c2d6064a40e79e"
}
]
}
Loading
Loading