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
1 change: 1 addition & 0 deletions research/shared-hub-seven-call/.gitattributes
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
retained/** -text whitespace=cr-at-eol
32 changes: 32 additions & 0 deletions research/shared-hub-seven-call/CREDITS.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,32 @@
# Sources and credit

Ali Romman (@aliromman) prepared this proof, checker and package with
substantial OpenAI Codex assistance. New material is Apache-2.0.
No independent human or formal proof-kernel acceptance is claimed.

Nick Petalas (@petalas) supplied the six-call theorem, unchanged checker
and seven-call question in [PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742),
at the [exact proof](https://github.com/petalas/integer-mult-bounds/blob/9394615e9fd3a30b66e23d422da4945258d7923f/research/shared-hub-single-pass/README.md)
and [checker](https://github.com/petalas/integer-mult-bounds/blob/9394615e9fd3a30b66e23d422da4945258d7923f/research/shared-hub-single-pass/verify.py).
All five package files are retained byte-exact. The integer bit-encoded
Laurent engine here adapts that source method; the bivariate set engine
is separate.

Ali Romman supplied the shared-hub projector pool in
[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707),
[source proof](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md),
and the four-relation theorem and cross-commutator lemma in
[PR #7711](https://github.com/CrocSwap/integer-mult-bounds/pull/7711),
[retained proof](https://github.com/aliromman/integer-mult-bounds/blob/ac185e4529a01156f7b574555b50827f8cb645bb/research/shared-hub-triple-word-obstruction/PROOF.md).
The displayed projector matrices are checked directly. The cross-commutator lemma is a dependency. The four-relation theorem is
related prior work; its complete predecessor suite is not rerun.

Jerry Jiaheng Chen (@CubeJerry) supplied the augmentation chronology method
in [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782),
[source word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md).
The source notices identify this credit. This package adds the complete first-nonzero-form case split and the
exact cuts for the repeated call with a higher augmentation order. It does not claim a new geometry theorem or physical realization.

`SOURCES.json` pins canonical main selection and task provenance.
`SOURCE-PINS.json` authenticates six retained source files. Source pins
are content references and do not assert unmerged ancestry.
225 changes: 225 additions & 0 deletions research/shared-hub-seven-call/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,225 @@
# Seven nonzero calls still require two blocks

Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.

Use the six projectors from Ali Romman's
[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707):

```text
A0=(6,5), A1=(5,6), A2=(7,7),
B0=(12,20), B1=(20,12), B2=(28,28).
```

The pair (u,v) means uv^T over F2, in coordinates 0 through 4. Each triple
is orthogonal. Their sums are DA=diag(1,1,1,0,0) and DB=diag(0,0,1,1,1).
A call with label a is I+([a]-1)P over F2[H], where H is the torsion-free
abelian group generated by the seven paid labels. Later calls act on the left.
Thus H=Z^7/L with L saturated. Every label is nonzero, one type occurs
twice, and the other five types occur once. There is no relation-rank limit.

**Theorem.** A diagonal endpoint in the original coordinates requires all A
calls before all B calls, or the reverse. The exact exponent totals of the
three A types are one common S, and those of the three B types are one
common T. Conversely these conditions give

```text
diag([S],[S],[S+T],[T],[T]).
```

In particular, no opposite-triple call can separate the repeated pair.
Any unused spectator coordinates remain fixed. Each target receives a
disjoint subset of paid labels, so the sum of rational target ranks is at
most the sum of paid ranks. This is an obstruction for the stated alphabet
without a relation-rank limit, not a new kappa or a physical supplier.

## 1. First nonzero terms

Choose an integral basis of the paid-generated group H. Expand each Laurent
variable at one in the formal power series ring over F2. The expansion is
injective, and its associated graded ring is a polynomial domain. Thus a
nonzero label has a coefficient [a]-1 of finite positive augmentation order.
This is the source method used in
[PR #7711](https://github.com/CrocSwap/integer-mult-bounds/pull/7711) and
[PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742).
Reflection of coordinates 0 through 4 exchanges the A and B triples, so
assume the repeated type is on the A side.

Let p be the least order of the four A coefficients, and q the least order
of the three B coefficients. At degree q, the two B-private off-diagonal
entries force all three B coefficients to have the same nonzero initial
form g. Pure A terms vanish there and all mixed terms have higher degree.
The B types are distinct and mutually orthogonal, so pure B products reduce
to the linear sum of their three projector coefficients.

Let f1 and f2 be the degree-p forms of the two repeated A coefficients.
A form is zero if that call has higher order. At degree p, the A-private
entries equate the three type coefficients. Hence both non-repeated A
coefficients have form f=f1+f2. The product of the two repeated coefficients
has degree at least 2p and does not enter here. At least one of f1,f2 is
nonzero; otherwise every A coefficient would have zero degree-p form.

## 2. The first mixed degree

Let Q be the span of the six off-patterns. The nine classes
C_ij=off(Ai Bj+Bj Ai) modulo Q have rank eight; their sole nonzero
dependence is the sum of all nine. This is the cross-commutator lemma of
PR7711. The checker reconstructs the matrices and tests all 511 nonempty
subsets.

Compare with the order in which all A calls precede all B calls. In degree
p+q its mixed part is fg DB DA, which is diagonal, including when f=0.
Pure off-diagonal terms lie in Q. Any term with at least three factors and
both triples has higher degree. Swapping an inverted A/B pair therefore
changes this degree by its two initial forms times C_ij.

The rank-eight lemma makes all nine inversion coefficients equal, after
cancelling the common nonzero factor g. Fix a B_j. Let alpha and beta
indicate that it precedes the first and second repeated calls, and let
epsilon be the corresponding indicator for either non-repeated A type.
Equality gives

```text
f1 alpha + f2 beta = (f1+f2) epsilon.
```

If f1=f2!=0, this forces alpha=beta. If f1 and f2 are distinct and both
nonzero, they are linearly independent over F2, so alpha=beta=epsilon.
In both cases B_j cannot separate the repeated pair. These alternatives
include every case where both repeated calls have order p.

If exactly one of f1,f2 is zero, the other is f!=0. The six visible calls
have initial forms f on A and g on B. Equality of the nine coefficients
then makes every visible A/B inversion indicator the same. Those six
calls form two blocks. The extra call has strictly higher augmentation
order. No restriction on its exact nonzero label follows from this step.
The exact argument below resolves its possible position.

## 3. The extra call cannot cross a B block

Invert the word if necessary, so that the visible A block comes before
the B block. Inversion reverses the order, negates exact labels and
preserves diagonality and the hypotheses. If the extra A call separates
from its partner, it lies inside or after the B block. Write the word as

```text
F_Bright F_Ai(x) F_Bleft F_Acore,
```

where x is nonzero. The two A-private rows of F_Bright are identity rows,
and the B-private columns of F_Acore are identity columns. The rectangle
from B-private input columns to A-private output rows is therefore

```text
([x]-1) u_i,private (F_Bleft)_(hub,B-private).
```

The private image u_i,private is nonzero for all three A types. The group
algebra is a domain and [x]-1 is nonzero. Hence the hub/private row of
F_Bleft must vanish. If its three B coefficients are beta0,beta1,beta2,
this says beta0=beta1=beta2. A missing B type has coefficient zero; each
present type has nonzero coefficient. A nonempty proper B prefix is
therefore impossible.

It remains to exclude the extra A call after the complete B block. The
same equations make that block DB(t), where t=[T] is a monomial different
from one. On the three A coordinates it is diag(1,1,t). Write

```text
F_Acore = I + a A0 + b A1 + c A2,
F_Ai(x) = I + d Ai, d=[x]-1 != 0.
```

Each of 1+a, 1+b and 1+c is a nonzero monomial.

For repeated A0, row zero forces b=c. With r=a+b, three required
off-diagonal zeros of W=(I+dA0)diag(1,1,t)F_Acore are

```text
W_10 = r + d(1+b+tr),
W_12 = r + dt(1+a),
W_20 = (1+d)tr + d(1+b).
```

The first and third sum to (1+t)r. Since t!=1, diagonality gives r=0.
The second then gives dt(1+a)=0, which contradicts the three nonzero
factors. Swapping the two A-private coordinates proves the A1 case.

For repeated A2, the sum W_02+W_12 equals a+b, so a=b. Put e=1+a and
r=a+c. Then F_Acore=eI+rJ, where J=A2 is the all-one three-by-three
matrix. The two entries

```text
W_01 = r + d(e+tr),
W_02 = r + dt(e+r)
```

sum to de(1+t), again a product of nonzero elements. This excludes A2.
All possibilities for the extra call are now covered, so the repeated
pair cannot have an opposite-triple call between its occurrences.

## 4. Exact totals and the complete endpoint

All calls between the repeated pair are from its own orthogonal triple.
They commute, so combine the repeated calls into one call at their exact
sum. This sum cannot be zero in a diagonal word. If it were zero, the
remaining A side would have only two nonzero distinct types. At its first
nonzero augmentation degree, the A-private entries would equate all three
type coefficients, including the missing zero coefficient, which is
impossible. Pure B terms vanish on that private square, and mixed terms
have strictly higher degree.

The combined word thus has six nonzero calls, one per type. Nick Petalas's
[PR #7742](https://github.com/CrocSwap/integer-mult-bounds/pull/7742)
forces its two triple blocks and exact common labels, for every
torsion-free abelian group. Expanding the combined call within its
same-triple interval preserves that block order. This proves necessity.
Orthogonality within each triple proves the converse and the displayed
endpoint directly.

Assign coordinate 0 all A0 paid labels, coordinate 1 all A1 labels,
coordinate 2 all A2 and B2 labels, coordinate 3 all B0 labels and
coordinate 4 all B1 labels. These subsets are disjoint. Rational matrix
rank subadditivity proves the paid-rank inequality, including both
occurrences of the repeated type. Spectators receive the empty subset.

## Exact checks and limits

The checker examines all 5,040 labelled call orders for each of the four
possible relations between the leading forms. These four cases are complete
up to a change of basis in their F2-span.

| Leading forms (f1,f2) | Passing orders | Passing orders with a separator |
| --- | ---: | ---: |
| (1,1) | 2,016 | 0 |
| (1,2), independent | 288 | 0 |
| (0,1) | 504 | 216 |
| (1,0) | 504 | 216 |

For the last two cases every passing visible six-call core has two blocks.
Exact symbolic matrix products check the exceptional cut identities for
all three repeated A types. Coordinate reflection checks the B cases.

Seven integer-vector fixtures realize all seven five-relation binary
quotients with nonzero labels generating Z^2. Six additional fixtures have
rank-one paid groups and six relations, with different augmentation orders
and signed totals. The gcd checks authenticate each paid group and the
saturated kernel. For each fixture and each of six repeated types, the
checker multiplies all 5,040 full Laurent words: 393,120 words in total.
Exactly 22,464 endpoints are diagonal, the 288 block orders in each of
78 cases, and every diagonal entry has the stated exponent. Integer bit encoding is injective on the
entire finite exponent support box. A separate bivariate set engine
checks 468 full products without that encoding.

The controls include a separating even repeated label that degree two
misses, a nonzero even change to one exact type total, and an omitted hub
contribution. The unchanged PR7742 verifier also checks its 527,040
six-call cases. All six retained source files are authenticated first.

The arbitrary-label result is the written proof. The finite fixtures do
not enumerate all saturated lattices. Eight or more
calls, other projector pools, arbitrary register changes, native
realization, physical storage and restoration, and the complete caller
invoice remain outside scope. The full PR7711 and geometry predecessor
suites, selected cold replay, Lean and Docker were not run. All five
framework assumptions remain. No human or formal proof-kernel acceptance
or global literature priority is claimed.
34 changes: 34 additions & 0 deletions research/shared-hub-seven-call/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
# Seven-call shared-hub obstruction

Seven nonzero calls, with one shared-hub type repeated, still require two triple blocks to give a
diagonal endpoint. The repeated calls cannot straddle a call from the
other triple. Exact totals give the same five target labels, and their
total rational rank cannot exceed the paid rank.

Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json),
[verify.py](verify.py), [SOURCE-PINS.json](SOURCE-PINS.json) and
[CREDITS.md](CREDITS.md). The proof handles both exceptional cases that
the degree-two check misses. The finite checker covers all four leading-form cases and all six choices
of repeated type. The theorem has no relation-rank limit.

Run from the repository root with Python 3.12 and the standard library:

```sh
python3.12 -B scripts/research_package.py --package research/shared-hub-seven-call
```

Both registered modes print `PASS_SHARED_HUB_SEVEN_CALL`. The retained
six-call verifier runs unchanged. The general theorem is a written proof;
finite replay is not formal proof-kernel acceptance.

No new kappa, physical supplier or selected-frontier change follows.
All five framework assumptions remain. The selected cold replay, Lean
and Docker were not run.

## Open next questions

- Resolve two repeated types at eight calls without a relation limit. The
visible-core and exact-cut arguments must then handle two extra calls.
A complete caller cost remains necessary for any physical proposal.

Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
Loading
Loading