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
50 changes: 50 additions & 0 deletions research/shared-hub-triple-word-obstruction/CREDITS.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
# Attribution and exact sources

Ali Romman prepared the new commutator lemma, word classification, full
endpoint argument and checks with substantial OpenAI Codex assistance.
New work is Apache-2.0. This is author-checked work, not 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
[exceptional six-projector pool](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md).
The pool, its irreducibility and geometric maximum remain prior results.
The [retained geometric credit chain](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/CREDITS.md)
identifies unpaidmoon's normal triples and different dimension-five
attainer, Nick Petalas's links and one-edge bound, and earlier pattern-
fiber work. Those results are not new here.

Ali Romman's [PR #7710](https://github.com/CrocSwap/integer-mult-bounds/pull/7710),
head `c396e9ee03b331f3b46aa87526817b237f5ad6f8`, gives the
[bridge-family obstruction and explicit sixth-projector exclusion](https://github.com/aliromman/integer-mult-bounds/blob/c396e9ee03b331f3b46aa87526817b237f5ad6f8/research/orthogonal-bridge-family-obstruction/PROOF.md).
It provides the open question. Its separate-bridge argument does not
prove the result here. The added projector changes the linear relations
to common totals within each triple.

Ali Romman's [PR #7695](https://github.com/CrocSwap/integer-mult-bounds/pull/7695),
head `996c002d82420141c19797e4e3b699ed88aee330`, supplies the prior
[augmentation and paid-subset argument](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/PROOF.md)
and the [binary, rank, degree-two and Laurent primitives](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/verify.py)
adapted in this checker. These routines are copied into the self-contained
package. No predecessor module is imported. The new allocation, chronology,
full-endpoint fixtures and controls concern the six-member pool.

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 word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md)
and [original recurrence](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/independent_five_word.py).
The nonzero-even-total control is an adaptation of that prior distinction,
not a newly discovered need to check exact exponents.

The consumed PR #7695 also retains Ali Romman's
[PR #7694](https://github.com/CrocSwap/integer-mult-bounds/pull/7694),
head `96b8b22f5925c4cf4514ed27575f465ebc95e51a`, and its
[edge-family proof](https://github.com/aliromman/integer-mult-bounds/blob/96b8b22f5925c4cf4514ed27575f465ebc95e51a/research/extremal-core-word-obstruction/PROOF.md).
Douglas Colkitt and the repository contributors supplied the framework,
task catalogue and package tools.

SOURCES.json pins main-branch provenance at
`e54523517d0f03e58352e647c403a5af3e525a57`. The unmerged proof and code
sources are pinned separately above. They are not represented as
ancestors of main. Their full replay suites were not rerun.
246 changes: 246 additions & 0 deletions research/shared-hub-triple-word-obstruction/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,246 @@
# Words on two normal triples with one common coordinate

Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
This is an author-checked scoped proof. It does not give a new kappa.

## 1. Exact statement

Work over F2. A pair of positive integers (x,y) denotes the rank-one
matrix `x y^T`, with binary digits in coordinate order 0 through 4.
Use exactly these six projectors:

```text
A0=(6,5), A1=(5,6), A2=(7,7),
B0=(12,20), B1=(20,12), B2=(28,28).
DA=A0+A1+A2=diag(1,1,1,0,0),
DB=B0+B1+B2=diag(0,0,1,1,1).
```

Each triple is orthogonal. The common coordinate is 2. The two other
coordinates of each triple are its private coordinates. The six-member
complete pool and its pattern dimension four are prior results of
[PR #7707](https://github.com/CrocSwap/integer-mult-bounds/pull/7707),
at the [source proof](https://github.com/aliromman/integer-mult-bounds/blob/57e24923b609d2588b83321f530fa2a1e75ed364/research/edge-matching-even-attainment/PROOF.md).
This proof uses the displayed matrices directly. It does not require
the source's full geometric maximum theorem.

An m-call word applies `I+([a_j]-1)P_j` in chronological order over
the group algebra F2[H]. The additive group H is the torsion-free
abelian group generated by its paid exponents a_j. Equivalently,
`H=Z^m/L`, where L is saturated. Every one of the six types occurs.
Require `rank(L)<=4`. Add any number of unused coordinate spectators.
Require a diagonal monomial endpoint on the full ambient space in
the original coordinate basis. A coordinate permutation is allowed;
an arbitrary ambient change of basis is not included.

Then all A calls occur before all B calls, or all B calls occur before
all A calls. The three A-type exponent totals are one common S, and
the three B-type totals are one common T. The five target exponents
are `(S,S,S+T,T,T)`. Spectators have exponent zero.

Conversely, this two-block chronology and these exact totals give that
full endpoint. This converse is an identity and needs no relation limit.
The necessity uses every stated hypothesis.

Each target is the sum of a disjoint subset of paid exponents: give
coordinates 0 and 1 the A0 and A1 calls, coordinates 3 and 4 the B0
and B1 calls, and coordinate 2 all A2 and B2 calls. Give spectators
the empty subset. Thus rational address-matrix rank subadditivity gives

```text
sum of target ranks <= sum of paid ranks.
```

All paid calls remain charged. There is no rank saving in this class.

## 2. The first-order quotient

Let off delete a matrix's diagonal, and let Q be the span of the six
off-patterns. It has dimension four. Within each triple the sum of
the patterns is zero. There are no other relations: in the two private
coordinates of A, the private off-diagonal entries of A0,A1,A2 are,
respectively, `E10`, `E01`, and `E10+E01`. The B triple has the same
property, with the private coordinate order reversed if necessary.
The two triple supports have no common off-diagonal entry.

Write U for the degree-one space of the augmentation ideal of F2[H].
Since H is the paid-generated torsion-free group, its degree-one
dimension is `m-rank(L)`. Its associated graded algebra is Sym(U).
This follows by choosing an integral basis of H and expanding its
Laurent variables at one. No larger ambient exponent group is used.

The endpoint's off-diagonal degree-one part is zero. Therefore the
type-total linear forms obey exactly four independent relations:

```text
sum(A0 calls) = sum(A1 calls) = sum(A2 calls) = u,
sum(B0 calls) = sum(B1 calls) = sum(B2 calls) = v. (1)
```

Each type occurs, so the four relations have rank four before quotient.
The limit `rank(L)<=4` forces equality and leaves no further linear
relation in U. In particular, u and v are independent.

For each type, retain all but one call variable and express its last
variable from (1). This is a basis description of U: u, v, and the
private retained variables of all six types. If E_i is the span of
the degree-one call variables of type Ai, then
`E_i=span(u, its private variables)`. If F_j is the corresponding span
for Bj, then `F_j=span(v, its private variables)`. Within each type,
all its call variables are independent. The subspaces from the A and
B sides are disjoint.

The augmentation method comes from CubeJerry's
[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782),
[word proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/FIVE-CORE-WORD.md).
The prior arbitrary-basis use and paid-group caveat are in
[PR #7695](https://github.com/CrocSwap/integer-mult-bounds/pull/7695),
[proof](https://github.com/aliromman/integer-mult-bounds/blob/996c002d82420141c19797e4e3b699ed88aee330/research/orthogonal-basis-bridge-obstruction/PROOF.md).
The present first-order equations differ from the bridge-total equations.

## 3. The cross-commutator lemma

Put `C_ij=off(Ai Bj+Bj Ai)` in the quotient by Q. The nine C_ij have
exactly one linear relation: their total sum is zero.

Here is a direct proof. For coefficients r_ij, restrict their sum to
the rectangle with A-private rows and B-private columns. The three
private image columns of A form a rank-two matrix X whose kernel is
the all-one vector. The three private covectors of B form a rank-two
matrix Y with the same kernel. Every cross factor pairing through the
common coordinate equals one. Thus this rectangle is `X R Y^T`.
Every matrix in Q is zero on it.

The kernel of `R -> X R Y^T` consists of `r_ij=s_i+t_j`. To check this,
choose two independent columns on each side. The four corresponding
entries determine the quotient map, which is onto the four-dimensional
space of two-by-two matrices. The displayed additive row-and-column
forms lie in its kernel and have dimension five. They are the full
kernel by dimension.

For this form, the full commutator sum is

```text
sum_i s_i [Ai,DB] + sum_j t_j [DA,Bj]. (2)
```

Here `[P,R]=PR+RP`. The first term is supported inside the A triple
and has only common/private entries; it has no private/private entry.
The second term has the corresponding support inside B. These off-
diagonal supports are disjoint. A member of the A-pattern space with
zero private/private entries is zero, by the explicit entries in
Section 2. The same is true for B. Thus membership of (2) in Q forces
both terms to vanish separately.

The common/private entries of the first term vanish exactly when the
private image sum and private covector sum vanish. Both two-by-three
matrices have all-one kernel, so s0=s1=s2. The same argument gives
t0=t1=t2. Thus all r_ij are equal. Conversely their common value one
gives `[DA,DB]=0`, since DA and DB are diagonal. This proves the lemma,
including the quotient by Q. Its rank is eight.

## 4. Degree two forces two blocks

For each pair i,j, define the quadratic polynomial q_ij to be the sum
of `a*b` over calls a of type Ai and calls b of type Bj for which b
occurs before a. These are degree-one call variables in U.

Compare the word's degree-two coefficient with the order in which all
A calls precede all B calls. Calls inside a triple commute exactly.
Each interchange of an A call and a B call changes the degree-two
matrix by its variable product times the corresponding commutator.
The degree-two terms of individual factors lie in Q after off. In
the comparison order, the first-order blocks are u DA and v DB, so
their cross term is diagonal. The remaining within-block terms lie
in Q. Therefore a diagonal endpoint requires

```text
sum_ij C_ij q_ij = 0 modulo Q. (3)
```

The rank-eight lemma, applied to each quadratic monomial separately,
makes all nine q_ij the same polynomial q.

For each i,j, q_ij lies in `E_i F_j`, the span of products of one
element of E_i and one element of F_j. The basis in Section 2 shows
that the intersection of these nine spaces is precisely span(uv).
Indeed a private variable of any one type is absent from the product
space for another type on that side. The only remaining monomial is
uv. Hence `q=epsilon*u*v`, where epsilon is zero or one.

Fix i,j. The call variables within Ai are a basis of E_i; those within
Bj are a basis of F_j. Their pairwise products are independent because
E_i and F_j lie in disjoint variable spaces. Their complete sum is uv,
by (1). Thus the coefficient of every call pair in q_ij is epsilon.
If epsilon is zero, every Ai call precedes every Bj call. If epsilon
is one, every Bj call precedes every Ai call. The same epsilon applies
to all nine pairs. This proves the two-block chronology at every length.

## 5. Exact totals and full endpoints

Degree one alone does not give exact equality of exponent totals.
Let the three exact A totals be S_i and the three exact B totals T_j.
After collecting calls within each block, its operator is

```text
FA = I + sum_i ([S_i]-1)Ai,
FB = I + sum_j ([T_j]-1)Bj. (4)
```

Suppose A precedes B, so the full map is FB FA. The two A-private
rows of FB are identity rows. They leave the corresponding rows of
FA unchanged. The private off-diagonal entries in those rows are
`[S_0]+[S_2]` and `[S_1]+[S_2]`. Diagonality forces all three monomials
equal. Distinct group elements are linearly independent in F2[H], so
S0=S1=S2 exactly.

The B-private columns of FA are identity columns. Thus the corresponding
columns of FB FA equal those of FB. Their private off-diagonal entries
force T0=T1=T2 by the same argument. If B precedes A, exchange the
roles of rows, columns and triples. The conclusion is unchanged.

Equation (4) now gives `FA=I+([S]-1)DA` and `FB=I+([T]-1)DB`.
These operators are diagonal, commute, and have the stated full endpoint.
Their common coordinate has monomial `[S][T]=[S+T]`. Every spectator
is fixed at each call. This proves necessity, sufficiency and the
disjoint paid-subset rank bound in Section 1.

## 6. Exact checks and limits

The checker tests all 511 nonempty subsets of the nine commutators,
including reduction modulo Q. Only the full subset vanishes. This
corroborates the direct rank lemma; it is not the unbounded proof.

Five multiplicity domains contain 68760 distinct type orders, with
1584 passing orders. Each has both a degree-two check and a full
original-coordinate Laurent product. The exponents use the universal
exact common-total lattice, with four relations. Every passing word
has the predicted full endpoint. Every other word has an off-diagonal
entry. A separate multinomial count gives each passing count. These
finite checks do not enumerate every saturated lattice with the same
modulo-two reduction; the written proof covers that distinction.

Twenty-four larger fixtures include repeated calls, both block orders,
coordinate permutations, and up to twelve unused spectators. They
check the actual paid exponent rank and all ambient columns. Moving
one call across the block boundary changes an explicit input column.

The controls also check two nonzero-even total changes at the same
four-relation rank. Degree two misses these changes; the full endpoint
rejects them. A larger ambient exponent group can hide an interleaving
after all labels are doubled; the correct paid-generated coordinates
reject it. At five relations, an interleaved diagonal word exists with
three zero calls. At six relations, an interleaved identity has every
call nonzero. These are boundary controls, not rank-saving constructions
or a classification above four relations. Omitted-type and wrong-hub-
target controls change the full map.

The exact six-type alphabet, all types present, original diagonal
endpoint, paid-generated group and four-relation limit are essential
scope restrictions. This does not classify other even maximizers or
arbitrary ambient embeddings. It does not supply a native word,
physical storage, restoration, a complete recursive invoice, or a
selected-assumption discharge. The selected kappa and all five
assumptions remain unchanged. Full predecessor suites, selected cold
replay, native/physical replay, Lean, Docker, independent human and
formal-kernel review were not run.
Loading
Loading