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
49 changes: 49 additions & 0 deletions research/orthogonal-bridge-family-obstruction/CREDITS.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,49 @@
# Attribution and source pins

Ali Romman prepared this bridge-family proof and its checks with substantial
OpenAI Codex assistance. New work is Apache-2.0. This is not an independent
review of the consumed source proofs.

Ali Romman's [PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707),
head `57e24923b609d2588b83321f530fa2a1e75ed364`, supplies the
[two-link construction and complete-pool exception](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md).
That geometry and its image maximum remain prior results. The new result
concerns paid words on the named alphabet and its stated family extension.
The sixth projector and other
maximizing pools remain outside this theorem.

Ali Romman's [PR #7695](https://github.com/CrocSwap/integer-mult-bounds/pull/7695),
head `996c002d82420141c19797e4e3b699ed88aee330`, supplies the
[Boolean diagonal partition, augmentation method and target matching](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/PROOF.md).
Its [checker](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/verify.py)
supplies the adapted binary matrix, exact rank, degree-two and Laurent
routines. The partition, exponent allocation, endpoint and census code
is adapted to a variable number of bridge types and both parities. Source code is copied
into this self-contained checker; no predecessor module is imported.

The new proof computes the exact bridge-family star kernel, separates the
independent bridge-variable sets, and removes all collected blocks
from the full endpoint. Mutual commutation permits literal interleaving;
the one-bridge consecutive-block conclusion is not asserted here.

The original chronology and Laurent methods are CubeJerry's work in
[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782),
head `685457252b51b9c7932ece363365bdf0b12c9c31`:
[five-core proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md)
and [original Laurent recurrence](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py).
Ali Romman's [PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694),
head `96b8b22f5925c4cf4514ed27575f465ebc95e51a`, supplies the
[edge-family extension](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md)
used by PR #7695. Its contribution remains prior work.

The [retained geometric credits](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/CREDITS.md)
identify unpaidmoon's normal triples and alternative dimension-five pool,
Nick Petalas's links and one-edge bound, and the earlier pattern-fiber
work. Those geometric results are not counted as new here. Douglas
Colkitt and the repository contributors supplied the research framework,
task catalogue and package tools.

SOURCES.json binds the main-branch provenance at
`e54523517d0f03e58352e647c403a5af3e525a57`. The unmerged consumed proof
and code commits are explicit above; they are not represented as
ancestors of main. Their complete replay suites were not rerun.
279 changes: 279 additions & 0 deletions research/orthogonal-bridge-family-obstruction/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,279 @@
# An orthogonal fresh-bridge family cannot save paid rank

Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
This is an all-width, all-length scalar-word proof with finite checks.
Independent human and formal-kernel review are not claimed.

## 1. Alphabet and theorem

Let E be an old coordinate space of dimension `N>=1`. Choose
`X in GL_N(F2)`. Its columns x_i and dual covectors y_i give the
orthogonal projectors `P_i=x_i y_i^T`. Put `h_x=sum_i x_i` and
`h_y=sum_i y_i`. Take b new, literal coordinate axes f_p, with `b>=1`.
Every projector is zero on any additional spectator coordinates.

Use the following binary matrix and its row covectors z_p:

```text
Z = I_b + (N modulo 2) J_b,
B_p = (h_x+f_p)(h_y+z_p)^T, p=1,...,b.
```

The pairings are `h_y h_x+Z_pq = N+Z_pq = delta_pq` over F2.
Thus all bridges are idempotent and `B_p B_q=0` for p different from q.
Their scalar calls commute. Require Z to be invertible, equivalently
`N*b` even. For even N, Z is the identity. For odd N and even b,
`Z^2=I_b`. If N and b are both odd, Z kills the nonzero all-one vector
and has rank b-1. That case is excluded.

At b=2 these are the two links of the attaining family in
[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707),
[source construction](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md),
extended here to an arbitrary old basis X and any permitted b.

A word has m calls `I+([A_j]-1)P_type(j)` over `R=F2[H]`. The group
H is the torsion-free abelian group generated by the paid exponents
A_j. Every old type and every bridge type occur. There are no other types.
Let k be the actual off-diagonal pattern dimension of this alphabet,
and let `L=kernel(Z^m -> H)` be the saturated relation lattice.
Assume `rank(L)<=k` and a full ambient diagonal monomial endpoint.

**Theorem.** No old call lies between the first and last occurrence
of any bridge type. By commuting only calls of different bridge types,
each type can be put in one block. Each block has exponent sum zero
and can be deleted on the full ambient space. Each physical target
exponent is then a sum of a disjoint subset of old paid exponents.
For rational address matrices, total target rank is at most total
paid rank.

Calls of one bridge type need not be consecutive in the literal word. For
example, `B1, B2, B1, B2` can be a cancelling bridge segment.
The theorem does not cover additional types, a larger relation budget,
arbitrary fresh embeddings or every pool that attains the image bound.
It gives no native supplier or complete multiplication invoice.

## 2. The inherited partition and linear kernel

The Boolean partition argument of
[PR #7695](https://github.com/CrocSwap/integer-mult-bounds/pull/7695),
[pinned proof](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/PROOF.md),
applies to every N. Define

```text
K_X = {c in F2^N : X diag(c) X^-1 is diagonal}.
```

It is a unital algebra under coordinatewise product. Indices that
have the same value in every member form d blocks. Products of
separating members, or their complements, give each block indicator.
Thus K_X consists exactly of the block-constant vectors and has
dimension d. The sum of the P_i in a block C is a diagonal projection
on an original coordinate set S_C of size `|C|`. These sets partition E.

The old pattern dimension is `N-d`. Each bridge has a distinct
nonzero fresh row against the old columns. Those rows make its pattern
independent of the old patterns and of all other bridge patterns. Hence
`k=N-d+b`.

Give every call its own variable `u_j=T_j-1`. Write U_i for the sum
of variables of old type i, and L_p for the total of bridge type p.
First-order diagonality gives the following k independent forms:

```text
L_p = 0 for every bridge type p,
U_i+U_ref(C) = 0 for each nonreference old type i in block C.
```

Every type occurs, so these forms are independent in the call
variables. Since H is paid-generated and free abelian, the defining
integer exact sequence splits. The substitution kernel on degree one
over F2 is `L/2L`, of dimension `rank(L)`. The assumed upper bound
therefore makes its dimension exactly k and gives the entire kernel.

The associated graded algebra of R at augmentation is `Sym(H/2H)`.
Its substitution kernel is the ideal generated by these linear forms.
This is a statement about the associated graded algebra, not a claim
that all Laurent relations are linear. The method comes from
CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782),
[five-core word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md),
and its extensions credited in PR #7695.

## 3. The exact star kernel

Change the old basis by X^-1 for the proof. Keep every f_p as its actual
coordinate axis. The old projectors become E_ii, and all old bridge
factors become the all-one vector of length N. The restricted physical
endpoint has an old block in
`A=X^-1 Diag(F2^N) X`, extended to R, and a fresh diagonal block.
Every binary matrix in A is idempotent.

Let Q be the span of all `off(B_p)` and `A_off`, and put
`K_i,p=off(B_p E_ii+E_ii B_p)`. The dimension of Q is `N-d+b=k`.
Consider a dependence modulo Q:

```text
sum_(i,p) c_i,p K_i,p = sum_p alpha_p off(B_p)+off(A0),
A0 in A.
```

Fresh row p against the old columns forces `c_i,p=alpha_p` for every i.
If N is odd, b is even and at least two. In each fresh row p, every
fresh off-diagonal entry on the right is alpha_p. The stars and A0
have zero entries there. Every alpha_p is zero. Thus all Nb stars
are independent modulo Q.

If N is even, the fresh block of each bridge is diagonal and gives no
further condition. The old block of the left side vanishes. Therefore
`off(A0)=(sum_p alpha_p)off(J_N)`. If the coefficient were one, A0
would have the form `J_N+D` for binary diagonal D. Since N is even,
`J_N^2=0`. The diagonal of `(J_N+D)^2` is diag(D), while the diagonal
of `J_N+D` is one plus diag(D). This contradicts idempotence of A0.
Hence `sum_p alpha_p=0`.

Conversely, every coefficient family `c_i,p=alpha_p` with
`sum_p alpha_p=0` gives a star combination in Q. The old blocks cancel,
and the cross rectangles are those of `sum_p alpha_p B_p`. Thus the
kernel has dimension b-1, with generators given by the sum of the stars
of bridge 1 and one other bridge. The star rank is `Nb-b+1`.
At b=1 this recovers the prior one-bridge independence. At b>1 the
dependences must be retained.

## 4. Independent bridge variables force the chronology

Project the universal word's off-diagonal terms to the quotient by Q.
Its terms of degree zero and one vanish before exponent substitution.
Nonlinear parts of that substitution cannot change its degree-two term.
Old/old products are diagonal. Products of different bridge types
are zero. Products of one bridge with itself are in Q.

Only old/bridge products remain. Modulo L_p, the bridge prefix and
suffix at an old call are equal. The projected degree-two expression
is `sum_(i,p) K_i,p q_i,p`, where

```text
q_i,p = sum over old calls j of type i
u_j times the sum of bridge-p variables before call j.
```

In the polynomial ring modulo the full linear-kernel ideal, odd N
gives `q_i,p=0`. For even N, q_i,p is independent of i for each p,
and `sum_p q_i,p=0` for every fixed i. This follows from the exact
star kernel. The statement holds coefficient by
coefficient in the binary star map, so it remains valid over the
quotient polynomial ring.

Eliminate the last variable of every bridge using its L_p. Fix an
old type i. Make i the reference for its partition block. In each
other type of that block, eliminate one call variable using equality
with U_i. In each other block, choose a reference and eliminate one
call variable in every nonreference type. Every needed call exists.
These substitutions fix all variables still present in the q_i,p
for this i, and eliminate all remaining kernel forms.

For odd N, each resulting polynomial is zero. For even N, their sum
over p is zero. Each polynomial uses only bridge-p variables, in
addition to the old type-i variables. Every term contains a bridge
variable. These monomial sets are disjoint. Every polynomial is zero
separately. This also covers a bridge with only one occurrence,
whose eliminated polynomial is already zero.

Distinct old calls have distinct remaining variables. The coefficient
of each such variable is its bridge prefix after the last bridge
variable has been eliminated. A proper, nonempty chronological prefix
is a nonzero sum of the first bridge variables. It cannot be zero.
Thus no old call is between the first and last call of any bridge type.

Each bridge type lies in one segment that contains only bridge calls.
All bridge types commute, so each can be collected within that
segment without crossing an old call. There are at most b resulting
bridge blocks, possibly with old maps between them.

## 5. Every block vanishes on the full ambient space

Let a block of type p have exponent total Z_p. Since Bp is idempotent,
its product is `I+([Z_p]-1)Bp`. Old maps are invertible on E and fix
the fresh coordinates.

Consider the last-acting bridge block p. Since Z is invertible, there
is a binary fresh vector v with `z_p(v)=1` and `z_q(v)=0` for every
q different from p. Before block p, every old map and every other block
fixes v. Block p produces old component `([Z_p]-1)h_x`. The old map
after it is invertible. A full diagonal endpoint sends a fresh vector
to a fresh vector, so this old component must be zero. The nonzero
binary vector h_x then gives `[Z_p]=1`, hence `Z_p=0` in H.
Delete that block. Repeat the same argument for the last remaining
bridge block. Every bridge total is zero.

These are identities for the original fixed ambient projectors, not
only for their restrictions to a selected image. The deletion therefore
holds on every input column, with all spectators retained. No free
physical change of basis is asserted.

After deletion the old endpoint is `X diag([T_i]) X^-1`, where T_i
is the total paid exponent of old type i. For each monomial label,
its binary mask of types belongs to K_X. Therefore T_i is constant
on each partition block C. All original coordinates of S_C receive
this common label. Match them bijectively to the `|C|` old types in C.
Each target exponent is the sum of the calls of its matched type;
different targets use disjoint subsets. Fresh and unused coordinates
have identity and receive the empty subset.

Rank subadditivity for rational address matrices now gives
`sum target ranks <= sum old paid ranks <= sum all paid ranks`.
The bridge calls remain charged in the original word.

## 6. Scope of the even-image corollary

Take the t unit pairs and r normal triples of PR #7707, with `t+r>0`.
Their old image and covector vectors are dual bases, with `N=2t+3r`
and `d=t+r`. The named alphabet with two fresh links has
`k=t+2r+2`, `nu=t` and `n=2t+3r+2`. This theorem excludes rank saving
for words that use every member of that named alphabet and have at
most k saturated exponent relations.

The source proves that this alphabet is the complete pool except at
`(t,r)=(0,1)`. In that case the complete pool also contains `(28,28)`.
Its off-pattern is `off(B1)+off(B2)`. If that extra type is allowed,
the two first-order equations couple to its total instead of setting
both bridge totals to zero. It is outside the theorem. Other even
maximizers, including the different pool in unpaidmoon's
[PR #7094](https://github.com/CrocSwap/integer-mult-bounds/pull/7094),
are not included without a separate equivalence proof.

## 7. Verification and limits

The checker enumerates all 20335 bases in GL_N(F2) for N=1,2,3,4.
For every permitted b from one through four, it checks their Boolean
partitions, physical coordinate multiplicities, actual pattern ranks and
star kernels. This gives 81002 basis/bridge-count checks. Twelve finite
word domains cover 55250 type orders. Their degree-two tests and full
original-coordinate Laurent products agree. Exactly 10148 pass.
A separate count assigns each bridge species to one of the N+1 gaps
between old calls. In each gap it counts all multiset interleavings,
then sums over assignments and multiplies by N!. At b=2 this reduces
to `N! (N+1) (N+binomial(h1+h2,h1))`.

Fifteen larger fixtures through old dimension ten and up to six bridges
include repeated old calls, three calls of one bridge, interleavings and
unused spectators. Deletion preserves their complete endpoints.
Removing one bridge call changes an explicit arbitrary fresh input.
Twenty wrong-parity links fail idempotence. Identifying the two free
bridge variables adds an exponent relation and hides one quadratic
rejection; the full Laurent endpoint still rejects that word. This
control checks why the independent-variable step needs its premise.
The exceptional sixth projector is checked as an excluded extra type.
Twelve odd-N, odd-b controls have an explicit nonzero common-kernel
vector on the fresh coordinates. Their singular Z is rejected.

Two further controls separate exact exponent statements from parity.
Doubling all exponent vectors hides degree two in a larger ambient
group, but does not repair the full endpoint. This tests why the proof
uses the paid-generated group. A nonzero even bridge total retains
the allowed relation rank and passes degree two in a collected word,
but its full endpoint fails. The exact block-deletion argument is needed.

The all-width and all-length conclusions use the written proof.
Finite tests do not enumerate all words or all old bases. No selected
cold replay, complete predecessor replay, native/physical implementation,
Lean, Docker, independent human or formal-kernel review was run. All
five selected assumptions remain. No new kappa is claimed.
Loading
Loading