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
109 changes: 109 additions & 0 deletions research/shared-hub-pentagon-query/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,109 @@
# Two pentagons with a shared hub need nine two-coordinate queries

This contribution was produced by Nick Petalas. Apache-2.0.

## Statement

Let G have vertices 0,...,8 and the two cycles

```text
0--1--2--3--4--0
0--5--6--7--8--0.
```

Over any field F, let M be an 18-by-18 matrix with 2-by-2 blocks indexed by
G. Require M_ii=I_2 and M_ij=0 for distinct nonadjacent i,j. Blocks at the
edges are unrestricted, including different matrices in the two directions.
Then the exact minimum of rank_F(M) is nine.

Equivalently, nine is the smallest field-coordinate dimension of a linear
query factorization M=AB satisfying this complete ordered-block contract.
This is a statement about algebraic query dimension. It does not count native
calls, physical COPY operations, arbitrary-input restoration or recursive cost.

## Lower bound

The independent set S={1,3,5,7} has identity principal submatrix I_8.
Consequently rank(M)>=8. Suppose for a contradiction that rank(M)=8, and
write M=AB with A having eight columns and B eight rows. Write A_i for the
two-row block of A and B_i for the two-column block of B, and U_i=im(B_i).

Since M[S,S]=I_8, the four U_s for s in S form a direct decomposition of the
eight-dimensional query space. The four A_s are its coordinate projections,
after identifying each U_s with F^2 using B_s. In these coordinates, the
ordered zeros M_sj=0 imply that B_j has no component in U_s whenever s,j
are distinct nonneighbors. In particular,

```text
U_4 is contained in U_3,
U_2 is contained in U_1 + U_3,
U_8 is contained in U_7,
U_6 is contained in U_5 + U_7.
```

Every B_i has rank two because A_i B_i=I_2. It follows that U_4=U_3 and
U_8=U_7. Since 2 and 4 are nonadjacent, A_2 B_4=0, so A_2 kills U_3.
Its restriction to U_2 is invertible. Therefore the projection of U_2 onto
U_1 along U_3 is injective. Both spaces have dimension two, so that
projection is surjective.

The hub decoder A_0 kills U_3 because 0 and 3 are nonadjacent, and kills
U_2 because 0 and 2 are nonadjacent. For every u in U_1, surjectivity gives
a v in U_2 with v=u+w for some w in U_3. Hence

```text
A_0 u = A_0 v - A_0 w = 0.
```

Thus A_0 kills U_1. The same argument on 6,8 shows that A_0 kills U_5.
It already kills U_7, since 0 and 7 are nonadjacent. It therefore kills
U_1+U_3+U_5+U_7, which is the entire query space. This contradicts
A_0 B_0=I_2. Rank eight is impossible, proving rank(M)>=9.

All steps use dimensions, invertibility and the specified ordered zeros.
They apply in every characteristic and do not assume symmetric, commuting
or invertible edge blocks. The independent-set argument alone gives only
eight; the two terminal saturation steps supply the extra dimension.

## Attainment

Write the two input coordinates at vertex i as x_(i,0),x_(i,1), and encode
coordinate (i,a) as the integer 2i+a. Form the following nine unordered pairs:

```text
(0,2), (3,4), (5,6), (7,8), (9,1),
(10,12), (11,13), (14,16), (15,17).
```

Every integer 0,...,17 occurs exactly once. Each pair joins coordinates
belonging to adjacent vertices. Query the sum of the two coordinates of
each pair. To recover one coordinate, its receiver subtracts the paired
coordinate, which its read mask permits.

More explicitly, let B have nine rows and eighteen columns, with one row
equal to the indicator of each pair, and set A=B^T. Then M=AB has I_2 in
every diagonal block and zero blocks at every nonedge. The columns of A
associated with different pairs have disjoint supports, so A has rank
nine. The same is true of the rows of B. Each pair contributes the rank-one
block [[1,1],[1,1]] on its two coordinates, including in characteristic two.
Thus rank(M)=9 over every field, as required.

Independent invertible changes of the two coordinates at each vertex give
L M L^-1. They preserve identity diagonals, the complete zero mask and
rank nine. They need not preserve symmetry or make the allowed blocks
commute. These transformations give the noncommuting finite fixtures.

## What this settles

For this shared-hub two-coordinate mask, arbitrary directed block coding
cannot improve on the nine-coordinate edge-pairing construction. The graph
is triangle-free and has overlapping odd cycles. Sharing a hub therefore
does not by itself provide a block-coding saving beyond coordinate pairing
in this two-pentagon example.

The lower argument is written here rather than inferred from a finite
matrix census. The verifier checks the supplied construction, literal
decoding and the local saturated-branch identities used in that argument.
It does not exhaust all fitting matrices and does not prove the universal
claim by enumeration. Larger payloads and other shared-cycle topologies
remain open within this package.
137 changes: 137 additions & 0 deletions research/shared-hub-pentagon-query/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,137 @@
# A shared hub between two pentagons needs nine query coordinates

This contribution was produced by Nick Petalas. Apache-2.0.
Independent human and formal proof-kernel review are unclaimed.

Claim type: scoped written mathematical proof, with exact finite conformance.
For the graph with cycles `0-1-2-3-4-0` and `0-5-6-7-8-0`, give every vertex
exactly two field coordinates. Over every field, the exact minimum fitting
rank is **nine**. Diagonal blocks are `I_2`; both ordered blocks at every
nonedge are zero; all allowed edge blocks are arbitrary 2-by-2 matrices.
They may be asymmetric, singular and noncommuting.

The independent-set bound gives eight. [PROOF.md](PROOF.md) excludes rank
eight by saturating that bound: terminal subspaces on both arms force the
hub decoder to annihilate the entire query space. Nine disjoint coordinate
pairs attain the bound. Thus this shared-hub mask gives no improvement over
optimal integral edge pairing, even with general directed block coding.
This is the original changed-mask result delivered here, not a claim of a
first result about overlapping cycles in general or of literature priority.

The card `complex-rank-shape-decoder` changes scope from complete supplier
construction to this algebraic decoder side result. It tests one proposed
route around single-cycle pairing obstructions. No source-bound physical
caller, complete signed invoice, new kappa or multiplication theorem follows.
The selected #7000 record and all frozen evidence remain unchanged.

## Exact evidence

The standalone verifier imports no project code and runs no predecessor
executable. It checks:

- 376 complete rank-nine factorizations over F2, F3, F5, F7, F101 and Q,
including asymmetric and noncommuting edge-block fixtures. Every one of
their 121,824 ordered entries satisfies the full diagonal/zero contract.
- All 262,144 binary input assignments to the nine-pair encoder and literal
side-information decoder, giving 4,718,592 coordinate recoveries.
- All 187,200 local normalized branch instances over F2 and F3 used by the
saturation proof. These enumerate invertible terminal/projection blocks
and arbitrary intermediate blocks. They are not all fitting matrices.
- Nine query omissions and three illegal diagonal/zero-mask edits reject.
A positive boundary control attains rank eight after adding only edge
`0-2`; the original zero-mask validator rejects that code.

The universal exclusion rests on the written proof. These finite checks
corroborate the construction and local algebra, without pretending to
exhaust the unrestricted 18-by-18 fitting-matrix space. The generated JSON
on stdout binds the results to SHA256 of all six package files. No receipt
is hand-written or retained as frozen evidence, and normal execution writes
nothing into the checkout.

## Reproduction

From the repository root, use standard-library CPython 3.12:

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/shared-hub-pentagon-query/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -O -B research/shared-hub-pentagon-query/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/shared-hub-pentagon-query
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/shared-hub-pentagon-query --check-source-history
```

Another CPython 3.12 executable may replace that path. Direct verification
prints `PASS_SHARED_HUB_PENTAGON_QUERY` in its JSON result, with minimum
query dimension nine. Both normal and optimized modes use explicit
exceptions. The registered runner executes both, each with a 120-second
limit. Hosted CI status belongs in the contribution PR body.

## Credit and overlap

JoyboyBrian's [#5023](https://github.com/CrocSwap/integer-mult-bounds/pull/5023)
supplies the unequal-payload odd-cycle query interface, with credit to
Tekalign #3362, Sagar Thakrar #2484, ywz65 #2471, Nick Petalas #4909,
Cinna Davis, Adam Gall, ctoth, Philippe Van Velzen and the retained
P112/native lineage. Its single-cycle theorem is credited background.
The proof here does not invoke its numerical results or construction.

Yossi Berliner and Michael Langberg's classical
[*Index coding with outerplanar side information*, Theorem 1.1](https://www.openu.ac.il/home/mikel/papers/outer.pdf)
settles the scalar outerplanar minimum through clique covers. Section 7
leaves vector-linear coding outside that paper's result. The contribution
here concerns two-coordinate blocks and a direct saturation proof.
Classical fitting-matrix rank factorization and coordinate-pair coding
retain their credit. No global first-discovery claim is made.

Nick Petalas's older `clebsch-puncture-query-gap` package studies a different
mask and a specified classical binary matrix. It is related background,
not the source of this question or a construction used in the main step.
No predecessor package is audited or scientifically replayed.

Canonical base is `e54523517d0f03e58352e647c403a5af3e525a57`, priority revision 8.
[SOURCES.json](SOURCES.json) pins the catalogue, selected record and odd-cycle
exposition as historical provenance. There are no live external inputs.
The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19595344)
records the same scope. Live open/recent-account PRs, Discussion claims,
local reservations, full-main distinctive README searches and merged-title
searches were checked. The cached scan covers remote pagination but omits
most sparse local notes; the full-main Git searches supplement that omission.
Arbitrary historical diffs and unpublished work remain outside coverage.

## Limitations and implementation constraints

This theorem is a linear dimension contract for this one graph and payload
width. Nonlinear coding, larger payloads and other topologies are unproved.
No physical source reads, query implementation, side-information acquisition,
owned or borrowed state, dirty restoration, frame conversions, coefficient
preparation, hosting, precision, tapes, stock, uniform compiler, complete
recursive invoice or supplier admission is provided. These unknown costs
are not treated as zero. There is no dependent implementation expansion.
No selected cold replay, Lean, Docker or formal proof-kernel build was run.

The verifier has no recursion, subprocesses, network or output-file path.
Every matrix is at most 18-by-18, all finite domains are literal constants,
and all functions are below sixty physical lines. Inputs are streamed,
including the 262,144 assignments; no table of those assignments is retained.
Explicit exceptions enforce contracts under optimization. Warning-strict
normal/optimized execution and syntax inspection supply local diagnostics.
No separate external static analyzer is claimed.

Power of Ten rule 3 has a bounded managed-runtime deviation. Python allocates
integer, Fraction and small collection objects during checking. The largest
matrix has 324 entries, GL2 lists contain at most 48 matrices, and one
branch/input/profile is processed at a time. There is no fixed-storage or
steady-service claim. Build the Lever led to the executable factorization
and repeatable checker; Prove It Works led to every-input literal decoding
and the original-mask rejection of the rank-eight boundary control.

## Open next questions

1. What is the exact minimum on this graph with three coordinates per vertex?
The same saturation argument excludes the independent-set bound twelve,
while the cycle-plus-path pairing recipe gives fourteen. Seek a rank-thirteen
factorization or exclude it. That case is not decided here.
2. Can an actual recursive caller expose this mask and benefit after complete
physical charges? Pin the producer, consumer and chronological read
permissions; then price source access, nine queries, side information,
restoration, frames and delivery. No such caller or native invoice is
supplied. A dimension optimum alone cannot establish profitability.
43 changes: 43 additions & 0 deletions research/shared-hub-pentagon-query/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,43 @@
{
"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/odd-cycle-query-capacity/README.md",
"usage": "provenance",
"git_blob": "55514f7ff0e239472ed2ca9c872c4cb2b8c53968",
"sha256": "7da79bbc83e6612e094fc040d6857343c97254ee10415a386b86406413350961"
},
{
"path": "research/odd-cycle-query-capacity/PROOF.md",
"usage": "provenance",
"git_blob": "5130e487b8f4e7c3f49cd4a654fe3fc51ce900b5",
"sha256": "fc99f405abd5df1c3f88563826f02b53783bba464d1a1852b5093126bf42637a"
}
],
"references": [
{
"url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5023",
"role": "Longer-cycle arbitrary-block model, credited background; no predecessor theorem or code is used in the new lower proof."
},
{
"url": "https://www.openu.ac.il/home/mikel/papers/outer.pdf",
"authors": "Yossi Berliner and Michael Langberg",
"title": "Index coding with outerplanar side information",
"locators": "Theorem 1.1; Section 7",
"role": "Classical scalar outerplanar result; vector-linear case left outside that paper. Not the new two-coordinate theorem."
}
]
}
Loading
Loading