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
42 changes: 42 additions & 0 deletions research/orthogonal-basis-bridge-obstruction/CREDITS.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,42 @@
# Sources and credit

Ali Romman prepared this proof and verifier with substantial OpenAI
Codex assistance. New work is Apache-2.0. Independent human and
formal-kernel review are unclaimed.

- Ali Romman's [PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694),
head `96b8b22f5925c4cf4514ed27575f465ebc95e51a`, supplies the prior
all-k extremal edge-core word obstruction and the full ambient
bridge-deletion argument. Read its
[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md).
Binary matrix, polynomial, type-order and Laurent routines are
adapted from its [verifier](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/verify.py).
- CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782),
head `685457252b51b9c7932ece363365bdf0b12c9c31`, supplies the original
five-core associated-graded and bridge-chronology proof:
[exact word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md).
Its [Laurent checker](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py)
is the original source of the adapted recurrence. The source notice
states that the work was prepared for @CubeJerry with substantial
OpenAI assistance. This adaptation is not an independent review.
- The no-edge seven-image corollary uses Ali Romman's
[PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691),
head `69e70b1426c32b19da8334930815800a2c95ffca`,
[exact classification](https://github.com/aliromman/integer-mult-bounds/blob/69e70b1426c32b19da8334930815800a2c95ffca/research/no-edge-dim5-extremal-classification/PROOF.md),
and [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690),
head `b725be51349cce4e0a262c76233838992042dd62`,
[exact image bound](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md).
The classification retains unpaidmoon's normal-triple and positive
link credit and Nick Petalas's nonsymmetric-link credit. Those
constructions and their pool geometry are prior work.

The new result concerns arbitrary even old bases, including coordinate
old calls. It uses the exact diagonal-intersection partition, a
basis-independent idempotence obstruction in the star quotient, and
physical target-multiplicity matching. The Boolean-algebra partition
itself is an elementary algebraic fact, not a new priority claim.

No external file is read at runtime. SOURCES.json binds the main
selected record and task catalogue as provenance. The corollary's
mathematical dependencies are linked at exact public commits; their
whole package replays are not part of this verifier.
291 changes: 291 additions & 0 deletions research/orthogonal-basis-bridge-obstruction/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,291 @@
# An orthogonal binary basis and one bridge 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 exact finite
checks. Independent human and formal-kernel review are unclaimed.

## 1. Alphabet and theorem

Let E be an old coordinate space of positive even dimension N. Choose
any `X in GL_N(F2)`. Its columns x_i and dual covectors y_i define

```
P_i = x_i y_i^T = X E_ii X^-1, i=1,...,N.
```

Extend these projectors by zero on all other coordinates. They are
mutually orthogonal and sum to the identity on E. Coordinate P_i are
allowed. Put `h_x=sum x_i` and `h_y=sum y_i`. On fresh coordinates
choose a,b with `a dot b=1`, and add the one fixed bridge

```
B = (h_x+a)(h_y+b)^T.
```

It is idempotent because `h_y dot h_x=N=0` in F2. Its incidences with
every old projector are one. On `V=E direct-sum F2*a`, the basis
`x_1,...,x_N,a` gives the old coordinate projectors and the all-one
matrix J of odd size N+1. This action is irreducible. A nonzero invariant
vector gives an old coordinate vector or lies on the fresh line. In
either case J gives the all-one vector; the old coordinate projectors
then recover every basis vector.

Consider a word of m calls using exactly these types, with every type present.
Its calls are `I+([A_j]-1)P_type` over `R=F2[H]`, where H is the
torsion-free abelian subgroup generated by all paid exponents A_j. Let k be
the actual off-diagonal pattern dimension of the alphabet, and let
`L=kernel(Z^m -> H)` be its saturated exponent relation lattice.
Assume `rank(L)<=k` and a full ambient diagonal monomial endpoint.

**Theorem.** All bridge calls form one consecutive block. Their
exponent sum is zero, and their block can be deleted in the full
ambient map. Every physical target exponent is the sum of a disjoint
subset of paid exponents. For rational address matrices, total target
rank is therefore at most paid rank.

The theorem permits coordinate old projectors and can have k=1.
It does not permit additional projector types. The change of basis
is a proof device, not a free physical operation. No native supplier,
rounding contract, complete multiplier invoice or new kappa follows.

The chronology 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 all-k edge-family extension in Ali Romman's
[PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694),
[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md).
The new steps handle an arbitrary X, its full linear kernel, and the
physical target multiplicities. The elementary Boolean-algebra fact
used below is not claimed as a new general algebraic result.

## 2. The exact diagonal-intersection partition

Define the binary coefficient space

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

This is a unital subalgebra of F2^N under coordinatewise multiplication.
Indeed, the map to `X diag(c) X^-1` preserves products, and diagonal
matrices are closed under products. Define i and j to be equivalent
when `c_i=c_j` for every c in K_X.

The indicator of each equivalence block belongs to K_X. To construct
it, choose an index in that block. For each other block choose an
element that separates their values. Replace it by one plus itself
if necessary to make its value one on the chosen block and zero on
the other block. The product of these elements is the desired
indicator. Thus K_X consists exactly of the vectors constant on
the d equivalence blocks, and has dimension d.

The old pattern map is `c -> off(X diag(c) X^-1)`, so it has rank N-d.
The bridge has nonzero old-to-fresh and fresh-to-old rectangles, while
all old projectors are supported on E. Its pattern is independent of
the old patterns. Therefore

```
k = N-d+1.
```

Singleton blocks are allowed. They are exactly the old coordinate
projectors: a singleton indicator in K_X says that P_i itself is a
diagonal rank-one idempotent.

For a block C, the sum `Q_C=sum_{i in C} P_i` is a diagonal projection.
Its rank is |C|, since these old projectors are orthogonal and have
independent images. Its active coordinate set S_C therefore has
size |C|. The sets S_C partition the original N coordinates. This
will give the physical multiplicity matching at the endpoint.

## 3. The full degree-one kernel

Give each call its own universal variable `u_j=T_j-1`. Put
`U_i=sum u_j` over old calls of type i and `L_B=sum u_j` over bridge
calls. First-order diagonality, and the independent bridge pattern,
give L_B=0 and equal U_i within each block of K_X. Use the forms

```
L_B, U_i+U_ref(C) for every nonreference i in each block C.
```

There are `1+N-d=k` independent forms. Every type occurs, so their
coefficient rows remain independent in the universal call variables.

The paid-generated group H is free abelian. Its defining exact
sequence with kernel L splits over the integers. Therefore the
linear substitution kernel `F2^m -> H/2H` is L/2L and has dimension
rank(L). The above k forms and `rank(L)<=k` imply equality, and give
the whole linear kernel.

The associated graded algebra of F2[H] at augmentation is
`Sym(H/2H)`: choose a free basis of H and use each basis monomial
minus one as a degree-one variable. The induced map of symmetric
algebras therefore has the ideal generated by the displayed linear
forms as its kernel. This does not assert that the Laurent relation
ideal itself is linear. An arbitrary larger ambient exponent group
cannot replace the paid-generated H in this parity argument.

## 4. Star independence for every old basis

Normalize the old basis by X^-1 on E and use a as the fresh basis
vector of V. The full endpoint preserves V. Since it is diagonal
in the original coordinates, every coordinate in the support of a
has the same endpoint monomial. Its restricted endpoint has an old
block in the algebra generated by

```
A = X^-1 diag(F2^N) X
```

after extension to R, and one fresh diagonal entry. Each binary
element of A is idempotent. Let A_off be its off-diagonal image,
embedded only in the old N-by-N block. Quotient the off-diagonal
(N+1)-dimensional matrix space by

```
Q = span(off(J_(N+1)), A_off).
```

For each old coordinate i, let
`K_i=off(J E_ii+E_ii J)`. These N stars are independent modulo Q.
Suppose `sum c_i K_i=lambda off(J)+off(A0)` for A0 in A. The fresh
row forces `c_i=lambda` for every old i. If lambda is one, the old
off-diagonal entries on the left are all zero. Thus
`off(A0)=off(J_N)`, and `A0=J_N+D` for a binary diagonal D.

This matrix cannot be idempotent when N is even. Since `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 lambda is zero and every c_i is zero.

This proof uses the actual conjugated diagonal algebra. Replacing
it by all old-block matrices loses the obstruction for a single
indecomposable block; the verifier includes that false-positive control.

## 5. The bridge calls are consecutive and cancel

The quotient Q kills the universal constant and linear word terms
before exponent substitution. Thus nonlinear substitution terms
cannot change its degree-two image. In normalized coordinates,
old/old products are diagonal and bridge/bridge products are J.
Only mixed products remain. Modulo L_B, the bridge prefix and suffix
at an old call are equal. The projected degree-two term is
`sum_i K_i q_i`, where

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

The star independence gives q_i in the full linear-kernel ideal.
Eliminate the last bridge variable using L_B. The resulting qbar_i
uses only old variables of type i and the first h-1 bridge variables.

Reanchor the block containing i at i. In every other type of that
block, solve its equality with U_i for one of its call variables.
For each other block, choose any reference type and solve for one
call variable of each nonreference type. Each such variable exists,
since every type occurs. These substitutions kill all the remaining
kernel generators and fix every variable in qbar_i. Singleton blocks
need no substitution. Consequently qbar_i is identically zero.

Each old call has a distinct universal variable. Its coefficient is
its bridge prefix after elimination. Every proper nonempty prefix
is a nonzero linear form in the first h-1 bridge variables. Thus no
old call lies between the first and last bridge calls. The bridge
calls are consecutive, including the immediate h=1 case.

Let Z be their exponent sum. The normalized word has the form
`D_left [I+([Z]-1)J] D_right` with monomial diagonal surrounding
matrices. A fresh-row/old-column entry is an invertible monomial
times `[Z]-1`. Such a cross entry is absent from the endpoint algebra,
so Z=0. The actual ambient bridge is one fixed idempotent B; its
consecutive calls multiply to `I+([Z]-1)B=I`. This deletes the block
on every ambient input, including dirty spectators outside V.

## 6. Physical target subsets

Let T_i be the sum of paid exponents of old type i. After the bridge
deletion, the old endpoint is `X diag([T_i]) X^-1`, and every other
coordinate has identity action. Full diagonality implies that, for
each monomial label, the binary mask of types with that label lies
in K_X. Thus the labels [T_i] are equal within each partition block C.

The endpoint on every original coordinate of S_C is this common
monomial. There are |C| such coordinates and |C| distinct old types
in C. Choose a bijection between them, and assign to each coordinate
the paid calls of its matched type. Its target is exactly their sum.
Different types give disjoint subsets. Give every spectator the empty
subset. This establishes a full physical target assignment without
assuming that X preserves diagonal targets or that its transport is free.

For rational address matrices, rank subadditivity gives
`sum target ranks <= sum nonbridge paid ranks <= sum all paid ranks`.
The bridge calls remain charged in the original invoice. This is
an exact scalar no-saving theorem, not a native implementation.

## 7. No-edge pattern-five corollary

Ali Romman's [PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691),
[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/69e70b1426c32b19da8334930815800a2c95ffca/research/no-edge-dim5-extremal-classification/PROOF.md),
classifies every complete unit-free pattern-five pool with irreducible
image seven. It is two disjoint normal triples plus a fresh-factor
link. Here N=6, d=2 with block sizes three and three, and k=5.
The present theorem excludes rank saving for every word on this pool
that uses all types and has at most five exponent relations.

This also applies when the actual word alphabet is only initially
given as unit-free pattern-five and irreducible image seven. The
total-image bound in [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690),
[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md),
makes its complete pool have the same image. That complete pool is
irreducible because it contains the actual alphabet. The cited
classification gives exactly seven independent image lines; the
actual image dimension seven forces every type to occur.

The normal triples and positive link family are prior work, with
unpaidmoon and Nick Petalas credited in the cited classification.
This corollary adds the word obstruction at five relations. It does
not cover smaller or reducible no-edge images or a larger relation budget.

## 8. Verification and limits

The verifier checks all six GL2 and all 20160 GL4 bases. For each it
computes the complete Boolean kernel, its partition, the physical
diagonal supports and the actual star quotient. Coordinate projectors,
mixed partitions and one indecomposable block are included.

Twelve word domains cover 130320 degree-two type orders. Three of
these domains also check 20880 full Laurent words in the original
coordinates: the coordinate four-basis, one orthogonal four-block,
and the two normal triples. Exactly 5280 have the predicted diagonal
endpoint. Every other full word has a nonzero off-diagonal entry.
Bridge exponents are assigned by chronology; these counts are type
orders, not separate permutations of labelled bridge occurrences.

Eight larger fixtures through old dimension ten include a repeated
old type, three cancelling bridge calls, nonsymmetric fresh factors
and unused spectator coordinates. Their actual relation rank equals
k. Complete ambient products agree with bridge deletion and with
the physical target-multiplicity assignment. Omitting one bridge
changes an explicit dirty column outside V. Eighty-four binary
diagonal perturbations of even all-one matrices check the idempotence
obstruction. The single-block coarse-quotient control and odd-dimension
guard both reject for their stated reasons.

The all-width and all-length claims rest on the proof. The finite
tests do not enumerate every old basis, ambient embedding or word.
Extra projector types, omitted types and larger relation budgets
are outside the theorem. Full predecessor package replays, selected
cold replay, Lean and Docker were not run. Independent human and
formal-kernel review are unclaimed. No native supplier, rounding
contract, complete multiplier invoice, selected-frontier change or
new kappa is supplied. All five selected assumptions remain.

## Open next questions

Can a specified second nonorthogonal bridge, or a larger relation
budget, support a legal saving? State the full alphabet and paid/target
invoice first. Failure of the present one-bridge hypotheses is not
evidence of a saving or of a native interface.
Loading
Loading