diff --git a/research/fifteenth-root-column-capacity/CREDITS.md b/research/fifteenth-root-column-capacity/CREDITS.md new file mode 100644 index 0000000000..005092c4ed --- /dev/null +++ b/research/fifteenth-root-column-capacity/CREDITS.md @@ -0,0 +1,32 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared the complete finite capacity 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. + +Ali Romman's [PR #7768](https://github.com/CrocSwap/integer-mult-bounds/pull/7768) +supplied the [general strict defect bound](https://github.com/aliromman/integer-mult-bounds/blob/fefebaf8285f3c46f75a815657acbf48780763fb/research/mixed-cycle-column-defect/PROOF.md) +and [open attainment question](https://github.com/aliromman/integer-mult-bounds/blob/fefebaf8285f3c46f75a815657acbf48780763fb/research/mixed-cycle-column-defect/README.md). +Three source notes are retained unchanged. This is motivation for the +finite task; the new capacity proof does not use its spectral bound. + +Ali Romman's [PR #7762](https://github.com/CrocSwap/integer-mult-bounds/pull/7762) +supplied the [projected-star proof and full eight-root census](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/PROOF.md) +and [unchanged checker](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/verify.py). +All sixteen package files remain byte-exact under `retained/source7762/`. +The finite census supplies the pair-normalization input. + +Nick Petalas (@petalas) supplied the two-prime projection and original +mixed-cycle question in [PR #7744](https://github.com/CrocSwap/integer-mult-bounds/pull/7744). +Its [proof and question](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/README.md) +and [checker](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/verify.py) +remain in the source closure and replay unchanged. All predecessor +notices, including the earlier completion work and David Ganz's +atlas credit, remain intact. + +The source credits T. Y. Lam and K. H. Leung for the classical +vanishing-cycle theorem. The present fixed-alphabet proof can use the +complete finite census instead. No global literature-priority claim +is made. Source commits are content pins, not claims of ancestry. +`SOURCE-PINS.json` authenticates all nineteen retained files. diff --git a/research/fifteenth-root-column-capacity/PROOF.md b/research/fifteenth-root-column-capacity/PROOF.md new file mode 100644 index 0000000000..668c92d847 --- /dev/null +++ b/research/fifteenth-root-column-capacity/PROOF.md @@ -0,0 +1,132 @@ +# Exactly four columns over fifteenth roots + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Let zeta be a primitive fifteenth root of unity. The largest number of +pairwise orthogonal columns of length eight with entries among powers of zeta is +exactly four. This resolves the q=5,b=1 attainment question in +[PR #7768](https://github.com/CrocSwap/integer-mult-bounds/pull/7768), +whose general column-defect bound permits five columns. + +This is a complete finite certificate with an attaining example. It is +not a failed search. Larger alphabets of order 3*5^b with b>1 remain +outside the finite domain. No physical supplier or new kappa follows. + +## 1. Normalize any pair of columns + +Row phases make the first column constant 1. The second column is now +a zero sum of eight fifteenth roots. The complete source census checks +all C(22,8)=319,770 multisets in the integral basis modulo + +```text +Phi_15(X) = X^8-X^7+X^5-X^4+X^3-X+1. +``` + +It finds exactly fifteen zero multisets. Each is one rotated 3-cycle +and one rotated 5-cycle. This also follows from the classical cycle +theorem, but the finite census suffices here. See the +[pinned source proof](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/PROOF.md) +and [unchanged source checker](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/verify.py). + +The fifteen multisets are exactly the scalar shifts of + +```text +v = (0,5,10,0,3,6,9,12), +``` + +where an exponent e denotes zeta^e. The checker compares both sets +exactly. A phase on the second column and a row permutation therefore +put every orthogonal pair into the form (1,zeta^v). These operations +preserve the alphabet and all other orthogonality relations. + +Each additional column can be scaled independently to make its first +entry 1. Its exponent vector then begins with zero. This does not +change the fixed pair. No row or column phase outside the original +alphabet is used. + +## 2. Enumerate every possible extension + +The new checker first examines all C(21,7)=116,280 nondecreasing +seven-term tails, with the first exponent fixed to zero. Polynomial +reduction finds exactly seven possible zero-sum supports. A recursive +multiset permutation gives all 20,160 normalized columns orthogonal +to the first column. A separate enumeration uses the fifteen rotated +cycle multisets and ordinary permutations. The two full sets agree. + +Exactly 95 candidates are also orthogonal to zeta^v. Every decision +is checked in two exact integral bases: direct polynomial division +by Phi_15 and the tensor basis of Q(omega,zeta_5). The basis map uses + +```text +zeta^e = omega^(2e) zeta_5^(2e). +``` + +The cycle-support membership check gives a third comparison for these +20,160 decisions. No floating-point tolerance is used. + +Let G have these 95 candidates as its vertices, in lexicographic order. +An edge means that the corresponding columns are orthogonal. All +C(95,2)=4,465 pairs are tested in both exact bases. The graph has twelve +edges. Its only nontrivial connected components are the cycles + +```text +0 -- 67 -- 2 -- 66 -- 1 -- 68 -- 0, +19 -- 51 -- 20 -- 52 -- 21 -- 53 -- 19. +``` + +The other 83 vertices are isolated. All vectors, edges and components +are in `RESULT.json`. Connected-component traversal checks these two +six-cycles. Separate checks examine every one of the 138,415 vertex +triples and every edge's bitset of common neighbors. Both find no +triangle. + +Five mutually orthogonal columns would give three additional columns +after pair normalization. They would form a triangle in G, which is +impossible. Thus at most four columns exist. With the fixed normalized +pair, there are exactly twelve four-column sets and 83 maximal +three-column sets. These are labeled, normalized counts, not counts +up to every matrix equivalence. + +## 3. An attaining matrix + +Use the following exponent matrix; replace each entry e by zeta^e. + +```text +0 0 0 0 +0 5 0 10 +0 10 10 5 +0 0 5 10 +0 3 6 4 +0 6 12 13 +0 9 3 7 +0 12 9 1 +``` + +The four columns are the constant column, v, vertex 0 and vertex 67. +The checker computes every Gram entry. Its diagonal is 8 and all +other entries are zero, in both exact bases. Therefore four columns +are attainable and the maximum is exactly four. + +The checker rejects all 448 changes obtained by replacing one entry +with any of the other fourteen roots. It also checks each candidate's +self-norm and distinguishes the wrong bilinear pairing that omits +complex conjugation. These controls make the orthogonality convention +explicit. + +## Evidence and limits + +All nineteen retained files have exact SHA-256 and Git-blob pins. +The complete PR7762 checker and its nested PR7744 replay run unchanged. +The new enumeration and full graph are checked in normal and optimized +Python modes. The saved certificate is compared with a full recomputation. +The statement is finite and exhaustive within the specified alphabet, +row count and exact orthogonality condition. + +The source general bound remains valid for every b>=1, but this sharp +capacity proof fixes b=1. It does not classify all matrices under full +row and column equivalence. Other row counts, larger alphabets, +approximate orthogonality, physical preparation and complete caller +pricing remain open. All five framework assumptions and the selected +frontier remain unchanged. No selected cold replay, Lean, Docker, +independent human acceptance or formal proof kernel was used. +No global literature priority is claimed. diff --git a/research/fifteenth-root-column-capacity/README.md b/research/fifteenth-root-column-capacity/README.md new file mode 100644 index 0000000000..37a2995b47 --- /dev/null +++ b/research/fifteenth-root-column-capacity/README.md @@ -0,0 +1,33 @@ +# Exact fifteenth-root column capacity + +Eight rows over fifteenth roots support exactly four orthogonal +columns. The proof gives an attaining matrix and excludes five by a +complete normalized extension graph. Its 95 vertices form two +six-cycles and 83 isolated vertices, so no triangle exists. + +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 general source bound permitted five +columns; this finite result determines the exact count. + +Run with Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/fifteenth-root-column-capacity +``` + +Both registered modes print `PASS_FIFTEENTH_ROOT_COLUMN_CAPACITY`. +The source verifier runs unchanged. No new kappa or physical supplier +follows. All five assumptions and the selected frontier remain. + +## Open next questions + +- Determine whether four is also the sharp count over roots of order + 3*5^b for b>1. First control the extra prime-power cosets; the present + normalization does not remove them. +- Resolve an exact column capacity at another row count and alphabet. + State a new finite domain or supply a general proof. +- Connect a valid matrix to a physical preparation and caller cost. + Exact orthogonality alone does not supply that implementation. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/fifteenth-root-column-capacity/RESULT.json b/research/fifteenth-root-column-capacity/RESULT.json new file mode 100644 index 0000000000..e762c8acce --- /dev/null +++ b/research/fifteenth-root-column-capacity/RESULT.json @@ -0,0 +1,1559 @@ +{ + "source_files": 19, + "exact_capacity": 4, + "enumeration": { + "tail_multisets_examined": 116280, + "zero_supports": [ + [ + 0, + 0, + 3, + 5, + 6, + 9, + 10, + 12 + ], + [ + 0, + 1, + 3, + 6, + 6, + 9, + 11, + 12 + ], + [ + 0, + 1, + 4, + 5, + 7, + 10, + 10, + 13 + ], + [ + 0, + 2, + 3, + 6, + 7, + 9, + 12, + 12 + ], + [ + 0, + 2, + 5, + 5, + 8, + 10, + 11, + 14 + ], + [ + 0, + 3, + 3, + 6, + 8, + 9, + 12, + 13 + ], + [ + 0, + 3, + 4, + 6, + 9, + 9, + 12, + 14 + ] + ], + "normalized_candidates": 20160, + "pair_normalization_orbit": [ + [ + 0, + 0, + 3, + 5, + 6, + 9, + 10, + 12 + ], + [ + 0, + 1, + 3, + 6, + 6, + 9, + 11, + 12 + ], + [ + 0, + 1, + 4, + 5, + 7, + 10, + 10, + 13 + ], + [ + 0, + 2, + 3, + 6, + 7, + 9, + 12, + 12 + ], + [ + 0, + 2, + 5, + 5, + 8, + 10, + 11, + 14 + ], + [ + 0, + 3, + 3, + 6, + 8, + 9, + 12, + 13 + ], + [ + 0, + 3, + 4, + 6, + 9, + 9, + 12, + 14 + ], + [ + 1, + 1, + 4, + 6, + 7, + 10, + 11, + 13 + ], + [ + 1, + 2, + 4, + 7, + 7, + 10, + 12, + 13 + ], + [ + 1, + 2, + 5, + 6, + 8, + 11, + 11, + 14 + ], + [ + 1, + 3, + 4, + 7, + 8, + 10, + 13, + 13 + ], + [ + 1, + 4, + 4, + 7, + 9, + 10, + 13, + 14 + ], + [ + 2, + 2, + 5, + 7, + 8, + 11, + 12, + 14 + ], + [ + 2, + 3, + 5, + 8, + 8, + 11, + 13, + 14 + ], + [ + 2, + 4, + 5, + 8, + 9, + 11, + 14, + 14 + ] + ] + }, + "extension_graph": { + "vertices": [ + [ + 0, + 0, + 10, + 5, + 6, + 12, + 3, + 9 + ], + [ + 0, + 0, + 10, + 5, + 9, + 3, + 12, + 6 + ], + [ + 0, + 0, + 10, + 5, + 12, + 9, + 6, + 3 + ], + [ + 0, + 1, + 11, + 3, + 9, + 12, + 6, + 6 + ], + [ + 0, + 1, + 11, + 6, + 6, + 12, + 3, + 9 + ], + [ + 0, + 1, + 11, + 6, + 9, + 3, + 12, + 6 + ], + [ + 0, + 1, + 11, + 6, + 12, + 9, + 6, + 3 + ], + [ + 0, + 1, + 11, + 9, + 6, + 12, + 6, + 3 + ], + [ + 0, + 2, + 12, + 7, + 6, + 12, + 3, + 9 + ], + [ + 0, + 2, + 12, + 7, + 9, + 3, + 12, + 6 + ], + [ + 0, + 2, + 12, + 7, + 12, + 9, + 6, + 3 + ], + [ + 0, + 3, + 13, + 8, + 6, + 12, + 3, + 9 + ], + [ + 0, + 3, + 13, + 8, + 9, + 3, + 12, + 6 + ], + [ + 0, + 3, + 13, + 8, + 12, + 9, + 6, + 3 + ], + [ + 0, + 4, + 14, + 6, + 12, + 9, + 3, + 9 + ], + [ + 0, + 4, + 14, + 9, + 6, + 12, + 3, + 9 + ], + [ + 0, + 4, + 14, + 9, + 9, + 3, + 12, + 6 + ], + [ + 0, + 4, + 14, + 9, + 12, + 9, + 6, + 3 + ], + [ + 0, + 4, + 14, + 12, + 9, + 9, + 3, + 6 + ], + [ + 0, + 5, + 0, + 10, + 6, + 12, + 3, + 9 + ], + [ + 0, + 5, + 0, + 10, + 9, + 3, + 12, + 6 + ], + [ + 0, + 5, + 0, + 10, + 12, + 9, + 6, + 3 + ], + [ + 0, + 6, + 1, + 11, + 6, + 12, + 3, + 9 + ], + [ + 0, + 6, + 1, + 11, + 9, + 3, + 12, + 6 + ], + [ + 0, + 6, + 1, + 11, + 12, + 9, + 6, + 3 + ], + [ + 0, + 7, + 2, + 3, + 12, + 12, + 6, + 9 + ], + [ + 0, + 7, + 2, + 6, + 12, + 3, + 12, + 9 + ], + [ + 0, + 7, + 2, + 12, + 6, + 12, + 3, + 9 + ], + [ + 0, + 7, + 2, + 12, + 9, + 3, + 12, + 6 + ], + [ + 0, + 7, + 2, + 12, + 12, + 9, + 6, + 3 + ], + [ + 0, + 8, + 3, + 13, + 6, + 12, + 3, + 9 + ], + [ + 0, + 8, + 3, + 13, + 9, + 3, + 12, + 6 + ], + [ + 0, + 8, + 3, + 13, + 12, + 9, + 6, + 3 + ], + [ + 0, + 9, + 4, + 14, + 6, + 12, + 3, + 9 + ], + [ + 0, + 9, + 4, + 14, + 9, + 3, + 12, + 6 + ], + [ + 0, + 9, + 4, + 14, + 12, + 9, + 6, + 3 + ], + [ + 0, + 10, + 5, + 0, + 6, + 12, + 3, + 9 + ], + [ + 0, + 10, + 5, + 0, + 9, + 3, + 12, + 6 + ], + [ + 0, + 10, + 5, + 0, + 12, + 9, + 6, + 3 + ], + [ + 0, + 10, + 5, + 1, + 7, + 13, + 4, + 10 + ], + [ + 0, + 10, + 5, + 1, + 10, + 4, + 13, + 7 + ], + [ + 0, + 10, + 5, + 1, + 13, + 10, + 7, + 4 + ], + [ + 0, + 10, + 5, + 2, + 8, + 14, + 5, + 11 + ], + [ + 0, + 10, + 5, + 2, + 11, + 5, + 14, + 8 + ], + [ + 0, + 10, + 5, + 2, + 14, + 11, + 8, + 5 + ], + [ + 0, + 10, + 5, + 3, + 0, + 12, + 9, + 6 + ], + [ + 0, + 10, + 5, + 3, + 9, + 0, + 6, + 12 + ], + [ + 0, + 10, + 5, + 3, + 12, + 6, + 0, + 9 + ], + [ + 0, + 10, + 5, + 4, + 1, + 13, + 10, + 7 + ], + [ + 0, + 10, + 5, + 4, + 10, + 1, + 7, + 13 + ], + [ + 0, + 10, + 5, + 4, + 13, + 7, + 1, + 10 + ], + [ + 0, + 10, + 5, + 5, + 2, + 14, + 11, + 8 + ], + [ + 0, + 10, + 5, + 5, + 11, + 2, + 8, + 14 + ], + [ + 0, + 10, + 5, + 5, + 14, + 8, + 2, + 11 + ], + [ + 0, + 10, + 5, + 6, + 0, + 9, + 3, + 12 + ], + [ + 0, + 10, + 5, + 6, + 3, + 0, + 12, + 9 + ], + [ + 0, + 10, + 5, + 6, + 12, + 3, + 9, + 0 + ], + [ + 0, + 10, + 5, + 7, + 1, + 10, + 4, + 13 + ], + [ + 0, + 10, + 5, + 7, + 4, + 1, + 13, + 10 + ], + [ + 0, + 10, + 5, + 7, + 13, + 4, + 10, + 1 + ], + [ + 0, + 10, + 5, + 8, + 2, + 11, + 5, + 14 + ], + [ + 0, + 10, + 5, + 8, + 5, + 2, + 14, + 11 + ], + [ + 0, + 10, + 5, + 8, + 14, + 5, + 11, + 2 + ], + [ + 0, + 10, + 5, + 9, + 0, + 6, + 12, + 3 + ], + [ + 0, + 10, + 5, + 9, + 3, + 12, + 6, + 0 + ], + [ + 0, + 10, + 5, + 9, + 6, + 3, + 0, + 12 + ], + [ + 0, + 10, + 5, + 10, + 1, + 7, + 13, + 4 + ], + [ + 0, + 10, + 5, + 10, + 4, + 13, + 7, + 1 + ], + [ + 0, + 10, + 5, + 10, + 7, + 4, + 1, + 13 + ], + [ + 0, + 10, + 5, + 11, + 2, + 8, + 14, + 5 + ], + [ + 0, + 10, + 5, + 11, + 5, + 14, + 8, + 2 + ], + [ + 0, + 10, + 5, + 11, + 8, + 5, + 2, + 14 + ], + [ + 0, + 10, + 5, + 12, + 3, + 9, + 0, + 6 + ], + [ + 0, + 10, + 5, + 12, + 6, + 0, + 9, + 3 + ], + [ + 0, + 10, + 5, + 12, + 9, + 6, + 3, + 0 + ], + [ + 0, + 10, + 5, + 13, + 4, + 10, + 1, + 7 + ], + [ + 0, + 10, + 5, + 13, + 7, + 1, + 10, + 4 + ], + [ + 0, + 10, + 5, + 13, + 10, + 7, + 4, + 1 + ], + [ + 0, + 10, + 5, + 14, + 5, + 11, + 2, + 8 + ], + [ + 0, + 10, + 5, + 14, + 8, + 2, + 11, + 5 + ], + [ + 0, + 10, + 5, + 14, + 11, + 8, + 5, + 2 + ], + [ + 0, + 11, + 6, + 1, + 6, + 12, + 3, + 9 + ], + [ + 0, + 11, + 6, + 1, + 9, + 3, + 12, + 6 + ], + [ + 0, + 11, + 6, + 1, + 12, + 9, + 6, + 3 + ], + [ + 0, + 12, + 7, + 2, + 6, + 12, + 3, + 9 + ], + [ + 0, + 12, + 7, + 2, + 9, + 3, + 12, + 6 + ], + [ + 0, + 12, + 7, + 2, + 12, + 9, + 6, + 3 + ], + [ + 0, + 13, + 8, + 3, + 6, + 12, + 3, + 9 + ], + [ + 0, + 13, + 8, + 3, + 9, + 3, + 12, + 6 + ], + [ + 0, + 13, + 8, + 3, + 12, + 9, + 6, + 3 + ], + [ + 0, + 13, + 8, + 9, + 6, + 3, + 12, + 3 + ], + [ + 0, + 13, + 8, + 12, + 6, + 9, + 3, + 3 + ], + [ + 0, + 14, + 9, + 4, + 6, + 12, + 3, + 9 + ], + [ + 0, + 14, + 9, + 4, + 9, + 3, + 12, + 6 + ], + [ + 0, + 14, + 9, + 4, + 12, + 9, + 6, + 3 + ] + ], + "edges": [ + [ + 0, + 67 + ], + [ + 0, + 68 + ], + [ + 1, + 66 + ], + [ + 1, + 68 + ], + [ + 2, + 66 + ], + [ + 2, + 67 + ], + [ + 19, + 51 + ], + [ + 19, + 53 + ], + [ + 20, + 51 + ], + [ + 20, + 52 + ], + [ + 21, + 52 + ], + [ + 21, + 53 + ] + ], + "components": [ + [ + 0, + 1, + 2, + 66, + 67, + 68 + ], + [ + 3 + ], + [ + 4 + ], + [ + 5 + ], + [ + 6 + ], + [ + 7 + ], + [ + 8 + ], + [ + 9 + ], + [ + 10 + ], + [ + 11 + ], + [ + 12 + ], + [ + 13 + ], + [ + 14 + ], + [ + 15 + ], + [ + 16 + ], + [ + 17 + ], + [ + 18 + ], + [ + 19, + 20, + 21, + 51, + 52, + 53 + ], + [ + 22 + ], + [ + 23 + ], + [ + 24 + ], + [ + 25 + ], + [ + 26 + ], + [ + 27 + ], + [ + 28 + ], + [ + 29 + ], + [ + 30 + ], + [ + 31 + ], + [ + 32 + ], + [ + 33 + ], + [ + 34 + ], + [ + 35 + ], + [ + 36 + ], + [ + 37 + ], + [ + 38 + ], + [ + 39 + ], + [ + 40 + ], + [ + 41 + ], + [ + 42 + ], + [ + 43 + ], + [ + 44 + ], + [ + 45 + ], + [ + 46 + ], + [ + 47 + ], + [ + 48 + ], + [ + 49 + ], + [ + 50 + ], + [ + 54 + ], + [ + 55 + ], + [ + 56 + ], + [ + 57 + ], + [ + 58 + ], + [ + 59 + ], + [ + 60 + ], + [ + 61 + ], + [ + 62 + ], + [ + 63 + ], + [ + 64 + ], + [ + 65 + ], + [ + 69 + ], + [ + 70 + ], + [ + 71 + ], + [ + 72 + ], + [ + 73 + ], + [ + 74 + ], + [ + 75 + ], + [ + 76 + ], + [ + 77 + ], + [ + 78 + ], + [ + 79 + ], + [ + 80 + ], + [ + 81 + ], + [ + 82 + ], + [ + 83 + ], + [ + 84 + ], + [ + 85 + ], + [ + 86 + ], + [ + 87 + ], + [ + 88 + ], + [ + 89 + ], + [ + 90 + ], + [ + 91 + ], + [ + 92 + ], + [ + 93 + ], + [ + 94 + ] + ], + "pair_checks": 4465, + "triple_checks": 138415, + "maximal_three_column_sets": 83, + "maximal_four_column_sets": 12, + "attaining_matrix_rows": [ + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 5, + 0, + 10 + ], + [ + 0, + 10, + 10, + 5 + ], + [ + 0, + 0, + 5, + 10 + ], + [ + 0, + 3, + 6, + 4 + ], + [ + 0, + 6, + 12, + 13 + ], + [ + 0, + 9, + 3, + 7 + ], + [ + 0, + 12, + 9, + 1 + ] + ], + "single_entry_mutations_rejected": 448, + "wrong_bilinear_edge_count": 1540 + } +} diff --git a/research/fifteenth-root-column-capacity/SOURCE-PINS.json b/research/fifteenth-root-column-capacity/SOURCE-PINS.json new file mode 100644 index 0000000000..2594116cf4 --- /dev/null +++ b/research/fifteenth-root-column-capacity/SOURCE-PINS.json @@ -0,0 +1,157 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/.gitattributes", + "retained": "retained/source7762/.gitattributes", + "git_blob": "130a3ecaa26bd4a35622a8c5c22f05f14cc4c665", + "sha256": "3a90a01036aab114f09495dd88d8cc7db233e784ba70377064f11ffa8a1602fd" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/CREDITS.md", + "retained": "retained/source7762/CREDITS.md", + "git_blob": "9ca00a2db881b4a7ca95f79372aad31fc08ff3c2", + "sha256": "0ba30859824881ba0129b911064b19215cad226232bb3a089724f22c8f5be5e9" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/PROOF.md", + "retained": "retained/source7762/PROOF.md", + "git_blob": "33f93945bad645ecd77cf6c00a6bca5bcef52ca4", + "sha256": "3f43b8ddeffce9e39057162fa4a15667b78e3bdd72da353d8e65aa3caa4d5203" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/README.md", + "retained": "retained/source7762/README.md", + "git_blob": "be36a951e7b38b169aa35d16d96206510d556cea", + "sha256": "8a0f975f986e766ef933a2b19165e6e0d46a9e03ed83d81326dcd4b315393fa5" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/RESULT.json", + "retained": "retained/source7762/RESULT.json", + "git_blob": "49eb2cf4ac9679a227766815b06014aac77c91c7", + "sha256": "749d0afb9fec09cca6ef7bca26c6659480402ea220a5e4d7200910ac32c500a4" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/SOURCE-PINS.json", + "retained": "retained/source7762/SOURCE-PINS.json", + "git_blob": "df8ae4bc660e2d13c9d90719ebbc3714b9678bb7", + "sha256": "5f5d4d629e205f572d82c57ffafc12ec2d0678e88f9c8a2ad6ce6fba7a400834" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/SOURCES.json", + "retained": "retained/source7762/SOURCES.json", + "git_blob": "5335fa97d97f6df5a917eea1ee2fcd01c082d261", + "sha256": "0761fd793723c2df1e2ca51733251cfd597ff3e120f7e2ee8ebb8e10e8e98c08" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/TASK.json", + "retained": "retained/source7762/TASK.json", + "git_blob": "f7b94713399e7e90b8c08354af4331d6ddc3efed", + "sha256": "c77a80f1233d8c3f0bb9992fce77d2593629605cb9ec7fa1fadca536b245ea93" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/VERIFY.json", + "retained": "retained/source7762/VERIFY.json", + "git_blob": "6b5afe14f23ec328a2af358dc85eb6ab5b3906cf", + "sha256": "74ba990fc0db5a43dc2e5f5af93483e3510d650807e9eba50781238c072d3ae5" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/column-completion-PROOF.md", + "retained": "retained/source7762/retained/column-completion-PROOF.md", + "git_blob": "5023cdde8762720467f708b28dabda0f0532064e", + "sha256": "b194084e203a70574397eeafae053af8e9e49d9e519aacfa112f039da2499674" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/two-prime/README.md", + "retained": "retained/source7762/retained/two-prime/README.md", + "git_blob": "1c9d65a78f4e8c8f1a7a15f48c30e372fada3f8f", + "sha256": "fd8223d9bee95195c5eceaa2212d52f1ab0e91ce6673ae9e18fb4d87d0ae638a" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/two-prime/SOURCES.json", + "retained": "retained/source7762/retained/two-prime/SOURCES.json", + "git_blob": "4b1a8b1b788fadf5cbc6b0d21cce51195cdab973", + "sha256": "b0b763a0aeda6400ac597c7cd39ab0ee47f1426345673986320e82354bc69e33" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/two-prime/TASK.json", + "retained": "retained/source7762/retained/two-prime/TASK.json", + "git_blob": "7fcc4e615ef5bbca3fbef73972828f4484aacaef", + "sha256": "a23e66700d55318ef684428bca00bdd6f421b2592dec379c0542737701ae79d9" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/two-prime/VERIFY.json", + "retained": "retained/source7762/retained/two-prime/VERIFY.json", + "git_blob": "807e154f99b58630fc1468c8ed999892af8b48e2", + "sha256": "953b105013e4448521e8e5f6ca3008bef14c47ee2785d45efdd7b9e664fa12c1" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/retained/two-prime/verify.py", + "retained": "retained/source7762/retained/two-prime/verify.py", + "git_blob": "f44c327017bc3e2720d4fb80c5374e43eb795dae", + "sha256": "cd7ebf036588a0f3fa108f05f5ad9cb3836c1abd7edde6e7507ee8fa0bba3691" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d33fe8562c86888307cbba4a2aa92490212c8d78", + "path": "research/mixed-cycle-column-obstruction/verify.py", + "retained": "retained/source7762/verify.py", + "git_blob": "7fe9f369d1c78f33ba045da235aa796e1db60f18", + "sha256": "3f875680dce9943ac503f87ae71adba3c4498f7b5d34cbf4b6e0afa492cbcccc" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "fefebaf8285f3c46f75a815657acbf48780763fb", + "path": "research/mixed-cycle-column-defect/CREDITS.md", + "retained": "retained/source7768/CREDITS.md", + "git_blob": "ba7ae62d840e35e35952f89ee297d622f3e92b71", + "sha256": "cf24781eb749a94f8a1dd287c0c577fbf783adddef96819e92f27dfac65d065e" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "fefebaf8285f3c46f75a815657acbf48780763fb", + "path": "research/mixed-cycle-column-defect/PROOF.md", + "retained": "retained/source7768/PROOF.md", + "git_blob": "88f7de6041c614551c50d2d1609e3d494f99028a", + "sha256": "8c95e31e7395ec9a1b16a8de616f4242e7d2ca3a4347e11fe76e4217231a3537" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "fefebaf8285f3c46f75a815657acbf48780763fb", + "path": "research/mixed-cycle-column-defect/README.md", + "retained": "retained/source7768/README.md", + "git_blob": "82a078431882496a1b2fb0e09b4f5efb0def334d", + "sha256": "f93ea6e248e30a6f09d8597696c5db8585f8a7850d1e1769c2e3f37e47ae1238" + } + ] +} diff --git a/research/fifteenth-root-column-capacity/SOURCES.json b/research/fifteenth-root-column-capacity/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/fifteenth-root-column-capacity/SOURCES.json @@ -0,0 +1,18 @@ +{ + "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" + } + ] +} diff --git a/research/fifteenth-root-column-capacity/TASK.json b/research/fifteenth-root-column-capacity/TASK.json new file mode 100644 index 0000000000..599b9bd2a0 --- /dev/null +++ b/research/fifteenth-root-column-capacity/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Exact maximum of four orthogonal columns in eight rows over fifteenth roots; complete normalized extension graph and attaining matrix.", + "scope_change_reason": "Resolve the q=5,b=1 attainment question left by the general strict column-defect bound in PR7768.", + "bottleneck_link": "Determine the exact column supply allowed by a specified cyclotomic alphabet. No physical supply or caller invoice is inferred.", + "budget_minutes": 60, + "stop_rule": "Stop at a proved scoped obstruction with exact checks, or report the failed implication. Do not infer nonexistence from a failed search.", + "outcome": "completed", + "evidence": "Complete exact cyclotomic census, two candidate enumerations, all pair tests, graph certificate and an attaining four-column matrix.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Does the same sharp count hold over roots of order 3*5^b for b>1?", + "why_it_matters": "The finite fifteenth-root census does not cover the larger alphabet.", + "first_step": "Classify the prime-power cosets in the vanishing inner products.", + "blocked_by": "Column normalization does not by itself remove the extra fifth-power phases." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/VERIFY.json b/research/fifteenth-root-column-capacity/VERIFY.json new file mode 100644 index 0000000000..bb39353ac6 --- /dev/null +++ b/research/fifteenth-root-column-capacity/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check the complete fifteenth-root census, two normalized column enumerations, all compatible pairs, component and triangle certificates, an attaining matrix and controls." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check the complete fifteenth-root census, two normalized column enumerations, all compatible pairs, component and triangle certificates, an attaining matrix and controls." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/.gitattributes b/research/fifteenth-root-column-capacity/retained/source7762/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/fifteenth-root-column-capacity/retained/source7762/CREDITS.md b/research/fifteenth-root-column-capacity/retained/source7762/CREDITS.md new file mode 100644 index 0000000000..9ca00a2db8 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/CREDITS.md @@ -0,0 +1,32 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared this proof, exact 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 two-prime projection and modular sign +argument, the released eight-row/fifteenth-root question, and the unchanged +fixture checker in [PR #7744](https://github.com/CrocSwap/integer-mult-bounds/pull/7744). +The retained [proof and question](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/README.md) +and [checker](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/verify.py) +identify the exact consumed version. All five source package files remain +byte-exact under `retained/two-prime/`. + +Nick Petalas also supplied the normalized missing-column formula and the +doubled-alphabet theorem in [PR #5865](https://github.com/CrocSwap/integer-mult-bounds/pull/5865). +Its [retained proof](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/cyclotomic-column-completion/PROOF.md) +is a dependency of Section 2. The source credits David Ganz for atlas B097 +and the pilot application in [PR #2849](https://github.com/CrocSwap/integer-mult-bounds/pull/2849) +and [PR #2855](https://github.com/CrocSwap/integer-mult-bounds/pull/2855). +Those applications are credited through the retained notices; their +scientific suites are not rerun here. + +T. Y. Lam and K. H. Leung supply the classical two-prime cycle decomposition +in [On Vanishing Sums of Roots of Unity, Theorem 3.3 and Corollary 3.4](https://arxiv.org/pdf/math/9511209#page=7). +The new argument uses projected Gram positivity, classifies the resulting +directed edges, removes the completion sign in the mixed case, and applies +a Hermitian trace obstruction. No global literature-priority claim is made. + +Source commits are content pins, not claims of ancestry. `SOURCES.json` +records the canonical main selection and catalogue. `SOURCE-PINS.json` +authenticates all six retained source files before the source replay. diff --git a/research/fifteenth-root-column-capacity/retained/source7762/PROOF.md b/research/fifteenth-root-column-capacity/retained/source7762/PROOF.md new file mode 100644 index 0000000000..33f93945ba --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/PROOF.md @@ -0,0 +1,172 @@ +# The mixed-cycle input does not exist + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Let q >= 5 be prime, b >= 1, n = q+3 and m = 3q^b. There is no +n-by-(n-1) matrix A with entries in the mth roots of unity and A* A = nI. +In particular, there is no eight-by-seven partial Butson matrix over the +fifteenth roots. This resolves the released input in +[PR #7744](https://github.com/CrocSwap/integer-mult-bounds/pull/7744). +It does not follow from failure to find a matrix. + +The proof first shows that any such partial matrix would complete in the +original alphabet. It then rules out that square completion. The two steps +are necessary: nonexistence of a square Butson matrix alone does not exclude +a partial matrix whose completion needs a larger alphabet. + +## 1. Projected Gram rigidity + +Write omega for a primitive third root and eta for a primitive q^bth root. +Every mth root is uniquely omega^x eta^y. Let pi discard eta, and put +B = pi(A), entry by entry. This is a map on the root group, not a +characteristic-zero ring homomorphism. + +Each inner product of distinct columns of A is a vanishing sum of n roots. +The two-prime cycle theorem of Lam and Leung decomposes it into rotated +3-cycles and q-cycles. The equation 3r+qs=q+3 has only the nonnegative +solution r=s=1: s is zero or one, and s=0 would require 3 to divide q. +Projection kills the 3-cycle and sends the q-cycle to q times a third root. +Thus B has diagonal column Gram entries n and off-diagonal entries q omega^a. +[Lam and Leung, Theorem 3.3 and Corollary 3.4](https://arxiv.org/pdf/math/9511209#page=7) + +For any three columns, the determinant of their Gram matrix is + +```text +n^3 - 3nq^2 + 2q^3 Re(omega^t), +``` + +where omega^t is the product of the three directed off-diagonal phases. +For t=0 this is 27(q+1). For t=1 or 2 it is + +```text +-3q^3 + 27q + 27 < 0, q >= 5. +``` + +For example, q^3 >= 25q makes the expression at most -48q+27. +A Gram matrix is positive semidefinite, so every triangle has t=0. +Scale the columns by third roots to make all off-diagonal Gram entries q. +Then scale rows by third roots to make the first column all ones. These +operations preserve the original alphabet and orthogonality of A. + +Each other projected column has sum q. Its three symbol counts therefore +satisfy c0-c2=q, c1-c2=0 and c0+c1+c2=q+3. Hence they are (q+1,1,1). +Each column is now the all-one column with omega at one row a and omega^2 +at a different row b. Represent it by the directed edge (a,b). + +Two different edges have projected inner product q exactly when they share +their first endpoint, share their second endpoint, or are reverses. This +follows by subtracting their two exponent vectors: the difference must +again have one 1 and one 2, with all other entries zero. A reverse pair +cannot have a third compatible edge. If two non-reverse edges have the +same first endpoint, every other compatible edge has that first endpoint; +the same argument applies to a common second endpoint. Thus a compatible +family of at least three edges is a directed star. + +For n-1 columns there are n-2 edges. Their distinct leaves and common +centre occupy n-1 rows, so exactly one row is unused. For n columns there +are n-1 edges, and the star occupies every row. Both orientations occur in +this necessary projected classification; it does not supply the q-part +of an actual orthogonal matrix. + +## 2. The partial input would complete without a negative sign + +Use the unused row u as the normalization row. The formula from +[PR #5865](https://github.com/CrocSwap/integer-mult-bounds/pull/5865) gives + +```text +w = (nI - AA*) e_u, w_u = 1, H = [A w]. +``` + +It proves H*H=nI and w_i in the 2mth roots. In particular each w_i is +eps omega^x eta^y with eps in {1,-1}. That theorem uses the rank-one +complement, integrality of the displayed formula and Kronecker's theorem; +we retain its proof as a dependency. + +Reduce in the ring R = F_q[X]/(X^2+X+1), with omega sent to X and eta +sent to 1. This is a ring map from Z[omega,eta], since the q^bth +cyclotomic polynomial takes the value q at 1. It commutes with inversion +of roots. R is nonzero and has odd characteristic. The powers of X have +odd order, so their coset and its negative are disjoint. This remains true +when R has zero divisors. + +The unused row of B is all ones. If the star has exponent s in {1,2} +at its centre and -s at each leaf, the projected row sums are + +| Row | Sum across the n-1 supplied columns | Negative sum modulo q | +| --- | --- | --- | +| Centre | 1 + (q+1) omega^s | omega^(-s) | +| Leaf | q+1 + omega^(-s) | omega^s | +| Unused | q+2 | The diagonal term makes w_u=1 | + +The completion formula therefore reduces each w_i to a positive power +of X. Disjoint sign cosets force eps=1 for every i. Thus H uses only +mth roots. Undoing the row and column phases preserves this property. +A different normalization row changes w by an mth root, so the conclusion +does not depend on which row was originally first. + +## 3. No square completion can have these parameters + +Apply Section 1 to a hypothetical n-by-n H. Its projected star has n-1 +leaves. Multiply its centre row by omega^(-s), and order rows and columns +so the constant column is first and each leaf matches its edge column. +The projected matrix then has omega^(-s) on the diagonal and 1 elsewhere. +Scale rows by q^bth roots to make the q-part of every diagonal entry 1. +Consequently + +```text +H = Q + (omega^(-s) - 1) I, +``` + +where Q has entries in the q^bth roots and Q_ii=1. + +For columns i and j, the two nontrivial third-root terms in their inner +product occur at rows i and j. In the unique one-3-cycle/one-q-cycle +decomposition, they must belong to the same 3-cycle, with the same q-part. +Their q-parts are Q_ij and conjugate(Q_ji). Thus Q is Hermitian. +Since omega+omega^2=-1, full orthogonality gives + +```text +HH* = Q^2 - 3Q + 3I = (q+3)I, +Q^2 - 3Q - qI = 0. +``` + +The two possible eigenvalues of Q are (3 +/- sqrt(9+4q))/2. If the first +has integer multiplicity k, the trace condition trace(Q)=n gives + +```text +(2k-n) sqrt(9+4q) = -n. +``` + +For odd q, 9+4q is 5 modulo 8 and cannot be a square. Its square root is +irrational. If 2k-n is nonzero, the displayed equation would make it +rational; if 2k-n is zero, it would give n=0. Both are impossible. +Thus no square H exists. Section 2 now excludes the partial A as well. + +## Evidence and limits + +The checker examines all 319,770 multisets of eight fifteenth roots in an +integer basis modulo Phi_15. Exactly 15 vanish, and these are exactly the +one-3-cycle/one-5-cycle multisets. This separately checks the source cycle +conclusion in the requested small case. + +It examines all 6,561 ternary words of length eight and all 1,540 pairs of +the resulting 56 edge words. A maximal-clique search gives exactly 16 +stars and 28 reverse pairs. A separate fixed-size search finds all 112 +six-edge configurations and compares them with the star subsets. Every +configuration passes the missing-column sign check in both orientations. + +For all 24 primes from 5 through 101 it checks 648 Gram phase assignments, +2,408 completion row residues and every possible spectral multiplicity. +Exact Eisenstein arithmetic checks the Hermitian matrix identity and +rejects missing conjugation, missing diagonal shift and a wrong linear +coefficient. Reverse-pair, nontrivial-phase, opposite-sign, nonorthogonal +projection and excluded-q controls mark the other boundaries. The pinned +PR7744 verifier runs unchanged in both registered modes. + +The theorem for arbitrary q and b is the written proof, not a conclusion +from finite sampling. The checker constructs no valid mixed-case input: +the theorem proves that none exists. No global literature priority is +claimed. Other row counts, more than two prime factors, larger powers of +three, noisy inputs and physical recovery remain outside scope. This +does not improve kappa or discharge any of the five framework assumptions. +No selected cold replay, Lean, Docker or formal proof kernel was run. diff --git a/research/fifteenth-root-column-capacity/retained/source7762/README.md b/research/fifteenth-root-column-capacity/retained/source7762/README.md new file mode 100644 index 0000000000..be36a951e7 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/README.md @@ -0,0 +1,38 @@ +# No mixed-cycle input at q+3 rows + +There is no (q+3)-by-(q+2) partial Butson matrix over roots of order +3q^b when q>=5 is prime and b>=1. In particular, the eight-row, +fifteenth-root input requested in PR7744 does not exist. + +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 first forces an original-alphabet +completion, then excludes it by a Hermitian trace contradiction. +It does not infer nonexistence from a search limit. + +Run from the repository root with Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/mixed-cycle-column-obstruction +``` + +Both registered modes print `PASS_MIXED_CYCLE_COLUMN_OBSTRUCTION`. +The retained source replay is unchanged. Exact finite checks support the +written proof; they are not a formal proof-kernel acceptance. + +No physical supplier, new kappa or selected-frontier change follows. +All five framework assumptions remain. The selected cold replay, Lean +and Docker were not run. + +## Open next questions + +- Resolve mixed-cycle counts that admit more than one cycle decomposition. + Start with the projected Gram constraints; the triangle argument above + depends on the precise ratio q/(q+3). +- Determine which parts survive an alphabet of order 3^a q^b with a>1. + The projected phases then have more than three possible values, so a + nontrivial triangle phase need not give a negative minor. +- Connect a valid recovery interface to a complete physical caller cost. + This package supplies an obstruction and no physical recovery routine. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/fifteenth-root-column-capacity/retained/source7762/RESULT.json b/research/fifteenth-root-column-capacity/retained/source7762/RESULT.json new file mode 100644 index 0000000000..49eb2cf4ac --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/RESULT.json @@ -0,0 +1,191 @@ +{ + "source_files": 6, + "root_sums": { + "multisets_examined": 319770, + "vanishing_multisets": [ + [0,0,3,5,6,9,10,12], + [0,1,3,6,6,9,11,12], + [0,1,4,5,7,10,10,13], + [0,2,3,6,7,9,12,12], + [0,2,5,5,8,10,11,14], + [0,3,3,6,8,9,12,13], + [0,3,4,6,9,9,12,14], + [1,1,4,6,7,10,11,13], + [1,2,4,7,7,10,12,13], + [1,2,5,6,8,11,11,14], + [1,3,4,7,8,10,13,13], + [1,4,4,7,9,10,13,14], + [2,2,5,7,8,11,12,14], + [2,3,5,8,8,11,13,14], + [2,4,5,8,9,11,14,14] + ] + }, + "eight_row_projection": { + "ternary_words_examined": 6561, + "edge_words": 56, + "pair_checks": 1540, + "maximal_cliques": 44, + "stars": 16, + "reverse_pairs": 28, + "partial_configurations": [ + {"edges":[[0,1],[0,2],[0,3],[0,4],[0,5],[0,6]],"reference":7,"completion_mod_five":[2,1,1,1,1,1,1,0]}, + {"edges":[[0,1],[0,2],[0,3],[0,4],[0,5],[0,7]],"reference":6,"completion_mod_five":[2,1,1,1,1,1,0,1]}, + {"edges":[[0,1],[0,2],[0,3],[0,4],[0,6],[0,7]],"reference":5,"completion_mod_five":[2,1,1,1,1,0,1,1]}, + {"edges":[[0,1],[0,2],[0,3],[0,5],[0,6],[0,7]],"reference":4,"completion_mod_five":[2,1,1,1,0,1,1,1]}, + {"edges":[[0,1],[0,2],[0,4],[0,5],[0,6],[0,7]],"reference":3,"completion_mod_five":[2,1,1,0,1,1,1,1]}, + {"edges":[[0,1],[0,3],[0,4],[0,5],[0,6],[0,7]],"reference":2,"completion_mod_five":[2,1,0,1,1,1,1,1]}, + {"edges":[[0,1],[2,1],[3,1],[4,1],[5,1],[6,1]],"reference":7,"completion_mod_five":[2,1,2,2,2,2,2,0]}, + {"edges":[[0,1],[2,1],[3,1],[4,1],[5,1],[7,1]],"reference":6,"completion_mod_five":[2,1,2,2,2,2,0,2]}, + {"edges":[[0,1],[2,1],[3,1],[4,1],[6,1],[7,1]],"reference":5,"completion_mod_five":[2,1,2,2,2,0,2,2]}, + {"edges":[[0,1],[2,1],[3,1],[5,1],[6,1],[7,1]],"reference":4,"completion_mod_five":[2,1,2,2,0,2,2,2]}, + {"edges":[[0,1],[2,1],[4,1],[5,1],[6,1],[7,1]],"reference":3,"completion_mod_five":[2,1,2,0,2,2,2,2]}, + {"edges":[[0,1],[3,1],[4,1],[5,1],[6,1],[7,1]],"reference":2,"completion_mod_five":[2,1,0,2,2,2,2,2]}, + {"edges":[[0,2],[0,3],[0,4],[0,5],[0,6],[0,7]],"reference":1,"completion_mod_five":[2,0,1,1,1,1,1,1]}, + {"edges":[[0,2],[1,2],[3,2],[4,2],[5,2],[6,2]],"reference":7,"completion_mod_five":[2,2,1,2,2,2,2,0]}, + {"edges":[[0,2],[1,2],[3,2],[4,2],[5,2],[7,2]],"reference":6,"completion_mod_five":[2,2,1,2,2,2,0,2]}, + {"edges":[[0,2],[1,2],[3,2],[4,2],[6,2],[7,2]],"reference":5,"completion_mod_five":[2,2,1,2,2,0,2,2]}, + {"edges":[[0,2],[1,2],[3,2],[5,2],[6,2],[7,2]],"reference":4,"completion_mod_five":[2,2,1,2,0,2,2,2]}, + {"edges":[[0,2],[1,2],[4,2],[5,2],[6,2],[7,2]],"reference":3,"completion_mod_five":[2,2,1,0,2,2,2,2]}, + {"edges":[[0,2],[3,2],[4,2],[5,2],[6,2],[7,2]],"reference":1,"completion_mod_five":[2,0,1,2,2,2,2,2]}, + {"edges":[[0,3],[1,3],[2,3],[4,3],[5,3],[6,3]],"reference":7,"completion_mod_five":[2,2,2,1,2,2,2,0]}, + {"edges":[[0,3],[1,3],[2,3],[4,3],[5,3],[7,3]],"reference":6,"completion_mod_five":[2,2,2,1,2,2,0,2]}, + {"edges":[[0,3],[1,3],[2,3],[4,3],[6,3],[7,3]],"reference":5,"completion_mod_five":[2,2,2,1,2,0,2,2]}, + {"edges":[[0,3],[1,3],[2,3],[5,3],[6,3],[7,3]],"reference":4,"completion_mod_five":[2,2,2,1,0,2,2,2]}, + {"edges":[[0,3],[1,3],[4,3],[5,3],[6,3],[7,3]],"reference":2,"completion_mod_five":[2,2,0,1,2,2,2,2]}, + {"edges":[[0,3],[2,3],[4,3],[5,3],[6,3],[7,3]],"reference":1,"completion_mod_five":[2,0,2,1,2,2,2,2]}, + {"edges":[[0,4],[1,4],[2,4],[3,4],[5,4],[6,4]],"reference":7,"completion_mod_five":[2,2,2,2,1,2,2,0]}, + {"edges":[[0,4],[1,4],[2,4],[3,4],[5,4],[7,4]],"reference":6,"completion_mod_five":[2,2,2,2,1,2,0,2]}, + {"edges":[[0,4],[1,4],[2,4],[3,4],[6,4],[7,4]],"reference":5,"completion_mod_five":[2,2,2,2,1,0,2,2]}, + {"edges":[[0,4],[1,4],[2,4],[5,4],[6,4],[7,4]],"reference":3,"completion_mod_five":[2,2,2,0,1,2,2,2]}, + {"edges":[[0,4],[1,4],[3,4],[5,4],[6,4],[7,4]],"reference":2,"completion_mod_five":[2,2,0,2,1,2,2,2]}, + {"edges":[[0,4],[2,4],[3,4],[5,4],[6,4],[7,4]],"reference":1,"completion_mod_five":[2,0,2,2,1,2,2,2]}, + {"edges":[[0,5],[1,5],[2,5],[3,5],[4,5],[6,5]],"reference":7,"completion_mod_five":[2,2,2,2,2,1,2,0]}, + {"edges":[[0,5],[1,5],[2,5],[3,5],[4,5],[7,5]],"reference":6,"completion_mod_five":[2,2,2,2,2,1,0,2]}, + {"edges":[[0,5],[1,5],[2,5],[3,5],[6,5],[7,5]],"reference":4,"completion_mod_five":[2,2,2,2,0,1,2,2]}, + {"edges":[[0,5],[1,5],[2,5],[4,5],[6,5],[7,5]],"reference":3,"completion_mod_five":[2,2,2,0,2,1,2,2]}, + {"edges":[[0,5],[1,5],[3,5],[4,5],[6,5],[7,5]],"reference":2,"completion_mod_five":[2,2,0,2,2,1,2,2]}, + {"edges":[[0,5],[2,5],[3,5],[4,5],[6,5],[7,5]],"reference":1,"completion_mod_five":[2,0,2,2,2,1,2,2]}, + {"edges":[[0,6],[1,6],[2,6],[3,6],[4,6],[5,6]],"reference":7,"completion_mod_five":[2,2,2,2,2,2,1,0]}, + {"edges":[[0,6],[1,6],[2,6],[3,6],[4,6],[7,6]],"reference":5,"completion_mod_five":[2,2,2,2,2,0,1,2]}, + {"edges":[[0,6],[1,6],[2,6],[3,6],[5,6],[7,6]],"reference":4,"completion_mod_five":[2,2,2,2,0,2,1,2]}, + {"edges":[[0,6],[1,6],[2,6],[4,6],[5,6],[7,6]],"reference":3,"completion_mod_five":[2,2,2,0,2,2,1,2]}, + {"edges":[[0,6],[1,6],[3,6],[4,6],[5,6],[7,6]],"reference":2,"completion_mod_five":[2,2,0,2,2,2,1,2]}, + {"edges":[[0,6],[2,6],[3,6],[4,6],[5,6],[7,6]],"reference":1,"completion_mod_five":[2,0,2,2,2,2,1,2]}, + {"edges":[[0,7],[1,7],[2,7],[3,7],[4,7],[5,7]],"reference":6,"completion_mod_five":[2,2,2,2,2,2,0,1]}, + {"edges":[[0,7],[1,7],[2,7],[3,7],[4,7],[6,7]],"reference":5,"completion_mod_five":[2,2,2,2,2,0,2,1]}, + {"edges":[[0,7],[1,7],[2,7],[3,7],[5,7],[6,7]],"reference":4,"completion_mod_five":[2,2,2,2,0,2,2,1]}, + {"edges":[[0,7],[1,7],[2,7],[4,7],[5,7],[6,7]],"reference":3,"completion_mod_five":[2,2,2,0,2,2,2,1]}, + {"edges":[[0,7],[1,7],[3,7],[4,7],[5,7],[6,7]],"reference":2,"completion_mod_five":[2,2,0,2,2,2,2,1]}, + {"edges":[[0,7],[2,7],[3,7],[4,7],[5,7],[6,7]],"reference":1,"completion_mod_five":[2,0,2,2,2,2,2,1]}, + {"edges":[[1,0],[1,2],[1,3],[1,4],[1,5],[1,6]],"reference":7,"completion_mod_five":[1,2,1,1,1,1,1,0]}, + {"edges":[[1,0],[1,2],[1,3],[1,4],[1,5],[1,7]],"reference":6,"completion_mod_five":[1,2,1,1,1,1,0,1]}, + {"edges":[[1,0],[1,2],[1,3],[1,4],[1,6],[1,7]],"reference":5,"completion_mod_five":[1,2,1,1,1,0,1,1]}, + {"edges":[[1,0],[1,2],[1,3],[1,5],[1,6],[1,7]],"reference":4,"completion_mod_five":[1,2,1,1,0,1,1,1]}, + {"edges":[[1,0],[1,2],[1,4],[1,5],[1,6],[1,7]],"reference":3,"completion_mod_five":[1,2,1,0,1,1,1,1]}, + {"edges":[[1,0],[1,3],[1,4],[1,5],[1,6],[1,7]],"reference":2,"completion_mod_five":[1,2,0,1,1,1,1,1]}, + {"edges":[[1,0],[2,0],[3,0],[4,0],[5,0],[6,0]],"reference":7,"completion_mod_five":[1,2,2,2,2,2,2,0]}, + {"edges":[[1,0],[2,0],[3,0],[4,0],[5,0],[7,0]],"reference":6,"completion_mod_five":[1,2,2,2,2,2,0,2]}, + {"edges":[[1,0],[2,0],[3,0],[4,0],[6,0],[7,0]],"reference":5,"completion_mod_five":[1,2,2,2,2,0,2,2]}, + {"edges":[[1,0],[2,0],[3,0],[5,0],[6,0],[7,0]],"reference":4,"completion_mod_five":[1,2,2,2,0,2,2,2]}, + {"edges":[[1,0],[2,0],[4,0],[5,0],[6,0],[7,0]],"reference":3,"completion_mod_five":[1,2,2,0,2,2,2,2]}, + {"edges":[[1,0],[3,0],[4,0],[5,0],[6,0],[7,0]],"reference":2,"completion_mod_five":[1,2,0,2,2,2,2,2]}, + {"edges":[[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]],"reference":0,"completion_mod_five":[0,2,1,1,1,1,1,1]}, + {"edges":[[1,2],[3,2],[4,2],[5,2],[6,2],[7,2]],"reference":0,"completion_mod_five":[0,2,1,2,2,2,2,2]}, + {"edges":[[1,3],[2,3],[4,3],[5,3],[6,3],[7,3]],"reference":0,"completion_mod_five":[0,2,2,1,2,2,2,2]}, + {"edges":[[1,4],[2,4],[3,4],[5,4],[6,4],[7,4]],"reference":0,"completion_mod_five":[0,2,2,2,1,2,2,2]}, + {"edges":[[1,5],[2,5],[3,5],[4,5],[6,5],[7,5]],"reference":0,"completion_mod_five":[0,2,2,2,2,1,2,2]}, + {"edges":[[1,6],[2,6],[3,6],[4,6],[5,6],[7,6]],"reference":0,"completion_mod_five":[0,2,2,2,2,2,1,2]}, + {"edges":[[1,7],[2,7],[3,7],[4,7],[5,7],[6,7]],"reference":0,"completion_mod_five":[0,2,2,2,2,2,2,1]}, + {"edges":[[2,0],[2,1],[2,3],[2,4],[2,5],[2,6]],"reference":7,"completion_mod_five":[1,1,2,1,1,1,1,0]}, + {"edges":[[2,0],[2,1],[2,3],[2,4],[2,5],[2,7]],"reference":6,"completion_mod_five":[1,1,2,1,1,1,0,1]}, + {"edges":[[2,0],[2,1],[2,3],[2,4],[2,6],[2,7]],"reference":5,"completion_mod_five":[1,1,2,1,1,0,1,1]}, + {"edges":[[2,0],[2,1],[2,3],[2,5],[2,6],[2,7]],"reference":4,"completion_mod_five":[1,1,2,1,0,1,1,1]}, + {"edges":[[2,0],[2,1],[2,4],[2,5],[2,6],[2,7]],"reference":3,"completion_mod_five":[1,1,2,0,1,1,1,1]}, + {"edges":[[2,0],[2,3],[2,4],[2,5],[2,6],[2,7]],"reference":1,"completion_mod_five":[1,0,2,1,1,1,1,1]}, + {"edges":[[2,0],[3,0],[4,0],[5,0],[6,0],[7,0]],"reference":1,"completion_mod_five":[1,0,2,2,2,2,2,2]}, + {"edges":[[2,1],[2,3],[2,4],[2,5],[2,6],[2,7]],"reference":0,"completion_mod_five":[0,1,2,1,1,1,1,1]}, + {"edges":[[2,1],[3,1],[4,1],[5,1],[6,1],[7,1]],"reference":0,"completion_mod_five":[0,1,2,2,2,2,2,2]}, + {"edges":[[3,0],[3,1],[3,2],[3,4],[3,5],[3,6]],"reference":7,"completion_mod_five":[1,1,1,2,1,1,1,0]}, + {"edges":[[3,0],[3,1],[3,2],[3,4],[3,5],[3,7]],"reference":6,"completion_mod_five":[1,1,1,2,1,1,0,1]}, + {"edges":[[3,0],[3,1],[3,2],[3,4],[3,6],[3,7]],"reference":5,"completion_mod_five":[1,1,1,2,1,0,1,1]}, + {"edges":[[3,0],[3,1],[3,2],[3,5],[3,6],[3,7]],"reference":4,"completion_mod_five":[1,1,1,2,0,1,1,1]}, + {"edges":[[3,0],[3,1],[3,4],[3,5],[3,6],[3,7]],"reference":2,"completion_mod_five":[1,1,0,2,1,1,1,1]}, + {"edges":[[3,0],[3,2],[3,4],[3,5],[3,6],[3,7]],"reference":1,"completion_mod_five":[1,0,1,2,1,1,1,1]}, + {"edges":[[3,1],[3,2],[3,4],[3,5],[3,6],[3,7]],"reference":0,"completion_mod_five":[0,1,1,2,1,1,1,1]}, + {"edges":[[4,0],[4,1],[4,2],[4,3],[4,5],[4,6]],"reference":7,"completion_mod_five":[1,1,1,1,2,1,1,0]}, + {"edges":[[4,0],[4,1],[4,2],[4,3],[4,5],[4,7]],"reference":6,"completion_mod_five":[1,1,1,1,2,1,0,1]}, + {"edges":[[4,0],[4,1],[4,2],[4,3],[4,6],[4,7]],"reference":5,"completion_mod_five":[1,1,1,1,2,0,1,1]}, + {"edges":[[4,0],[4,1],[4,2],[4,5],[4,6],[4,7]],"reference":3,"completion_mod_five":[1,1,1,0,2,1,1,1]}, + {"edges":[[4,0],[4,1],[4,3],[4,5],[4,6],[4,7]],"reference":2,"completion_mod_five":[1,1,0,1,2,1,1,1]}, + {"edges":[[4,0],[4,2],[4,3],[4,5],[4,6],[4,7]],"reference":1,"completion_mod_five":[1,0,1,1,2,1,1,1]}, + {"edges":[[4,1],[4,2],[4,3],[4,5],[4,6],[4,7]],"reference":0,"completion_mod_five":[0,1,1,1,2,1,1,1]}, + {"edges":[[5,0],[5,1],[5,2],[5,3],[5,4],[5,6]],"reference":7,"completion_mod_five":[1,1,1,1,1,2,1,0]}, + {"edges":[[5,0],[5,1],[5,2],[5,3],[5,4],[5,7]],"reference":6,"completion_mod_five":[1,1,1,1,1,2,0,1]}, + {"edges":[[5,0],[5,1],[5,2],[5,3],[5,6],[5,7]],"reference":4,"completion_mod_five":[1,1,1,1,0,2,1,1]}, + {"edges":[[5,0],[5,1],[5,2],[5,4],[5,6],[5,7]],"reference":3,"completion_mod_five":[1,1,1,0,1,2,1,1]}, + {"edges":[[5,0],[5,1],[5,3],[5,4],[5,6],[5,7]],"reference":2,"completion_mod_five":[1,1,0,1,1,2,1,1]}, + {"edges":[[5,0],[5,2],[5,3],[5,4],[5,6],[5,7]],"reference":1,"completion_mod_five":[1,0,1,1,1,2,1,1]}, + {"edges":[[5,1],[5,2],[5,3],[5,4],[5,6],[5,7]],"reference":0,"completion_mod_five":[0,1,1,1,1,2,1,1]}, + {"edges":[[6,0],[6,1],[6,2],[6,3],[6,4],[6,5]],"reference":7,"completion_mod_five":[1,1,1,1,1,1,2,0]}, + {"edges":[[6,0],[6,1],[6,2],[6,3],[6,4],[6,7]],"reference":5,"completion_mod_five":[1,1,1,1,1,0,2,1]}, + {"edges":[[6,0],[6,1],[6,2],[6,3],[6,5],[6,7]],"reference":4,"completion_mod_five":[1,1,1,1,0,1,2,1]}, + {"edges":[[6,0],[6,1],[6,2],[6,4],[6,5],[6,7]],"reference":3,"completion_mod_five":[1,1,1,0,1,1,2,1]}, + {"edges":[[6,0],[6,1],[6,3],[6,4],[6,5],[6,7]],"reference":2,"completion_mod_five":[1,1,0,1,1,1,2,1]}, + {"edges":[[6,0],[6,2],[6,3],[6,4],[6,5],[6,7]],"reference":1,"completion_mod_five":[1,0,1,1,1,1,2,1]}, + {"edges":[[6,1],[6,2],[6,3],[6,4],[6,5],[6,7]],"reference":0,"completion_mod_five":[0,1,1,1,1,1,2,1]}, + {"edges":[[7,0],[7,1],[7,2],[7,3],[7,4],[7,5]],"reference":6,"completion_mod_five":[1,1,1,1,1,1,0,2]}, + {"edges":[[7,0],[7,1],[7,2],[7,3],[7,4],[7,6]],"reference":5,"completion_mod_five":[1,1,1,1,1,0,1,2]}, + {"edges":[[7,0],[7,1],[7,2],[7,3],[7,5],[7,6]],"reference":4,"completion_mod_five":[1,1,1,1,0,1,1,2]}, + {"edges":[[7,0],[7,1],[7,2],[7,4],[7,5],[7,6]],"reference":3,"completion_mod_five":[1,1,1,0,1,1,1,2]}, + {"edges":[[7,0],[7,1],[7,3],[7,4],[7,5],[7,6]],"reference":2,"completion_mod_five":[1,1,0,1,1,1,1,2]}, + {"edges":[[7,0],[7,2],[7,3],[7,4],[7,5],[7,6]],"reference":1,"completion_mod_five":[1,0,1,1,1,1,1,2]}, + {"edges":[[7,1],[7,2],[7,3],[7,4],[7,5],[7,6]],"reference":0,"completion_mod_five":[0,1,1,1,1,1,1,2]} + ] + }, + "general_steps": { + "primes": [ + {"q":5,"rows":8,"balanced_determinant":162,"unbalanced_determinant":-213,"discriminant":29}, + {"q":7,"rows":10,"balanced_determinant":216,"unbalanced_determinant":-813,"discriminant":37}, + {"q":11,"rows":14,"balanced_determinant":324,"unbalanced_determinant":-3669,"discriminant":53}, + {"q":13,"rows":16,"balanced_determinant":378,"unbalanced_determinant":-6213,"discriminant":61}, + {"q":17,"rows":20,"balanced_determinant":486,"unbalanced_determinant":-14253,"discriminant":77}, + {"q":19,"rows":22,"balanced_determinant":540,"unbalanced_determinant":-20037,"discriminant":85}, + {"q":23,"rows":26,"balanced_determinant":648,"unbalanced_determinant":-35853,"discriminant":101}, + {"q":29,"rows":32,"balanced_determinant":810,"unbalanced_determinant":-72357,"discriminant":125}, + {"q":31,"rows":34,"balanced_determinant":864,"unbalanced_determinant":-88509,"discriminant":133}, + {"q":37,"rows":40,"balanced_determinant":1026,"unbalanced_determinant":-150933,"discriminant":157}, + {"q":41,"rows":44,"balanced_determinant":1134,"unbalanced_determinant":-205629,"discriminant":173}, + {"q":43,"rows":46,"balanced_determinant":1188,"unbalanced_determinant":-237333,"discriminant":181}, + {"q":47,"rows":50,"balanced_determinant":1296,"unbalanced_determinant":-310173,"discriminant":197}, + {"q":53,"rows":56,"balanced_determinant":1458,"unbalanced_determinant":-445173,"discriminant":221}, + {"q":59,"rows":62,"balanced_determinant":1620,"unbalanced_determinant":-614517,"discriminant":245}, + {"q":61,"rows":64,"balanced_determinant":1674,"unbalanced_determinant":-679269,"discriminant":253}, + {"q":67,"rows":70,"balanced_determinant":1836,"unbalanced_determinant":-900453,"discriminant":277}, + {"q":71,"rows":74,"balanced_determinant":1944,"unbalanced_determinant":-1071789,"discriminant":293}, + {"q":73,"rows":76,"balanced_determinant":1998,"unbalanced_determinant":-1165053,"discriminant":301}, + {"q":79,"rows":82,"balanced_determinant":2160,"unbalanced_determinant":-1476957,"discriminant":325}, + {"q":83,"rows":86,"balanced_determinant":2268,"unbalanced_determinant":-1713093,"discriminant":341}, + {"q":89,"rows":92,"balanced_determinant":2430,"unbalanced_determinant":-2112477,"discriminant":365}, + {"q":97,"rows":100,"balanced_determinant":2646,"unbalanced_determinant":-2735373,"discriminant":397}, + {"q":101,"rows":104,"balanced_determinant":2754,"unbalanced_determinant":-3088149,"discriminant":413} + ], + "triangle_cases": 648, + "sign_rows": 2408, + "controls": [ + "reverse pair", + "nontrivial triangle phase", + "nonorthogonal projection", + "opposite completion sign", + "excluded q=3 boundary" + ], + "spectral_identity": { + "orientations": 2, + "entries_per_orientation": 9, + "faults": [ + "conjugation", + "diagonal shift", + "linear coefficient" + ] + } + } +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/SOURCE-PINS.json b/research/fifteenth-root-column-capacity/retained/source7762/SOURCE-PINS.json new file mode 100644 index 0000000000..df8ae4bc66 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/SOURCE-PINS.json @@ -0,0 +1,53 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/two-prime-column-completion/README.md", + "retained": "retained/two-prime/README.md", + "git_blob": "1c9d65a78f4e8c8f1a7a15f48c30e372fada3f8f", + "sha256": "fd8223d9bee95195c5eceaa2212d52f1ab0e91ce6673ae9e18fb4d87d0ae638a" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/two-prime-column-completion/verify.py", + "retained": "retained/two-prime/verify.py", + "git_blob": "f44c327017bc3e2720d4fb80c5374e43eb795dae", + "sha256": "cd7ebf036588a0f3fa108f05f5ad9cb3836c1abd7edde6e7507ee8fa0bba3691" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/two-prime-column-completion/VERIFY.json", + "retained": "retained/two-prime/VERIFY.json", + "git_blob": "807e154f99b58630fc1468c8ed999892af8b48e2", + "sha256": "953b105013e4448521e8e5f6ca3008bef14c47ee2785d45efdd7b9e664fa12c1" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/two-prime-column-completion/TASK.json", + "retained": "retained/two-prime/TASK.json", + "git_blob": "7fcc4e615ef5bbca3fbef73972828f4484aacaef", + "sha256": "a23e66700d55318ef684428bca00bdd6f421b2592dec379c0542737701ae79d9" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/two-prime-column-completion/SOURCES.json", + "retained": "retained/two-prime/SOURCES.json", + "git_blob": "4b1a8b1b788fadf5cbc6b0d21cce51195cdab973", + "sha256": "b0b763a0aeda6400ac597c7cd39ab0ee47f1426345673986320e82354bc69e33" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "7dc85513e8ee9b771a5856f027cf199936f85af0", + "path": "research/cyclotomic-column-completion/PROOF.md", + "retained": "retained/column-completion-PROOF.md", + "git_blob": "5023cdde8762720467f708b28dabda0f0532064e", + "sha256": "b194084e203a70574397eeafae053af8e9e49d9e519aacfa112f039da2499674" + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/SOURCES.json b/research/fifteenth-root-column-capacity/retained/source7762/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/SOURCES.json @@ -0,0 +1,18 @@ +{ + "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" + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/TASK.json b/research/fifteenth-root-column-capacity/retained/source7762/TASK.json new file mode 100644 index 0000000000..f7b9471339 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "No (q+3)-by-(q+2) partial Butson matrix over roots of order 3q^b, for q prime at least five and b positive; includes n=8,m=15.", + "scope_change_reason": "Resolve the released PR7744 mixed-cycle missing-column question through projected Gram rigidity, original-alphabet completion and a spectral contradiction.", + "bottleneck_link": "Exact alphabet compatibility of the missing-column recovery interface; physical preparation, consumption and the complete caller bill remain open.", + "budget_minutes": 60, + "stop_rule": "Stop at a proved scoped obstruction with exact checks, or report the failed implication. Do not infer nonexistence from a failed search.", + "outcome": "negative-result", + "evidence": "PROOF.md supplies the general argument; RESULT.json and verify.py supply complete eight-row checks and bounded general controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Other mixed-cycle row counts and larger powers of three.", + "why_it_matters": "The input obstruction does not cover these alphabets and row counts.", + "first_step": "Derive the projected Gram constraints at one specified row count.", + "blocked_by": "The unique-cycle and triangle-rigidity arguments can fail." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/VERIFY.json b/research/fifteenth-root-column-capacity/retained/source7762/VERIFY.json new file mode 100644 index 0000000000..6b5afe14f2 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check exact mixed sums, projected Gram phases, the complete eight-row edge classification, sign residues, spectral obstruction and controls." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check exact mixed sums, projected Gram phases, the complete eight-row edge classification, sign residues, spectral obstruction and controls." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/column-completion-PROOF.md b/research/fifteenth-root-column-capacity/retained/source7762/retained/column-completion-PROOF.md new file mode 100644 index 0000000000..5023cdde87 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/column-completion-PROOF.md @@ -0,0 +1,125 @@ +# One-column cyclotomic completion + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Statement + +Write mu_m for the mth roots of unity. Let m,n>=2 and let A be an +n-by-(n-1) matrix with entries in mu_m and A* A=nI. Then its unique +orthogonal flat completion whose new column starts with 1 is + +```text +w = (nI-AA*) e_1, H = [A w]. (1) +``` + +It satisfies H*H=nI and has entries in mu_lcm(2,m). Moreover: + +1. If m is even, every entry of w belongs to mu_m, for every n>=2. +2. If m is an odd prime power and n>=3, every entry of w belongs to mu_m. + +Thus composite even alphabets and odd prime-power alphabets retain their +original alphabet. Both the matrix order n and alphabet order m are arbitrary +under these hypotheses; they need not agree. This extends the prime-order +statement B097 of David Ganz's atlas, PR2849. That result and PR2855's +prime pilot application are cited rather than reverified here. + +The n>=3 condition in the second conclusion is necessary. For any odd m, +the valid two-row input A=(1,1)^T has normalized completion (1,-1)^T. +Even allowing a global phase cannot put both entries in mu_m, since their +ratio is -1. The doubled-alphabet conclusion is therefore sharp without +a restriction on n. No sharpness assertion is made for odd composite m +and n>=3. + +## The flat column and its integral entries + +Set C=nI-AA*. Since A*A=nI, C is Hermitian, C^2=nC, and rank C=1. +Every diagonal entry of AA* is n-1, so C has diagonal 1. A rank-one +Hermitian positive matrix with C_11=1 satisfies C=C e_1 e_1* C. +Consequently C=ww*, |w_i|=1 and w_1=1. Also A*C=0, so A*w=0. +The squared norm of w is n, proving H*H=nI. The orthogonal complement +of A's columns has dimension one, proving normalized uniqueness. + +For i>1 the formula is explicitly + +```text +w_i = -sum_(j=1)^(n-1) A_ij conjugate(A_1j). (2) +``` + +Hence w_i belongs to Z[zeta_m] and is an algebraic integer. No division by +n or a determinant denominator occurs. This is the useful integrality +property behind the alphabet extension. + +## The classical cyclotomic facts + +We use cyclotomic irreducibility and [Q(zeta_r):Q]=phi(r). Here are the +remaining arguments, to make their exact use explicit. + +If alpha in Z[zeta_m] satisfies |alpha|=1, then alpha conjugate(alpha)=1. +All automorphisms of Q(zeta_m) commute with complex conjugation, since this +Galois group is abelian. Applying an automorphism therefore shows that +every algebraic conjugate of alpha has modulus one. Kronecker's theorem +implies that alpha is a root of unity. + +For completeness, the needed Kronecker argument is finite. If alpha has +degree d, each power alpha^k is an algebraic integer of degree at most d, +and every conjugate still has modulus one. Coefficients of its monic +minimal polynomial are integer elementary symmetric sums, bounded in +absolute value by the corresponding binomial coefficients of degree at +most d. Only finitely many such polynomials exist, and each has finitely +many roots. Thus the sequence alpha,alpha^2,... has finitely many possible +values. Two powers agree; alpha!=0 then implies a positive power equals 1. + +Put M=lcm(2,m). The roots of unity in Q(zeta_m)=Q(zeta_M) are exactly +mu_M. Indeed, if a primitive tth root lies in this field, the compositum +with Q(zeta_M) is Q(zeta_l), l=lcm(M,t). Thus phi(l)=phi(M). +Because M is even and M divides l, the product formula for phi shows +that increasing any existing prime exponent or adjoining any new odd +prime strictly increases phi. It follows that l=M and t divides M. +The reverse inclusion is immediate, using zeta_2m=-zeta_m^((m+1)/2) +when m is odd. These are classical facts, not new number-theory claims. + +Applying them to every entry in (2) proves w_i in mu_M. For even m, +M=m, proving the first conclusion. + +## Removing the sign for odd prime powers + +Let m=p^a for an odd prime p and a>=1. Evaluation at zeta_m=1 followed +by reduction modulo p defines a ring map + +```text +rho: Z[zeta_m] -> F_p, rho(zeta_m)=1, +``` + +because Phi_(p^a)(1)=p. If n>=3, A has two distinct columns. Their +orthogonality is a sum of n elements of mu_m equal to zero. Applying +rho shows p divides n. Applying rho to (2) now gives + +```text +rho(w_i) = -(n-1) = 1 in F_p. +``` + +Every element of mu_2m is either zeta_m^k or -zeta_m^k. Their images +under rho are respectively 1 and -1, which differ because p is odd. +Therefore each w_i lies in mu_m. The first entry already equals 1. +This proves the second conclusion and completes the theorem. + +## Sources and scope + +David Ganz's atlas B082/B097 in PR2849 supplies the one-column and +prime-order setting and explicitly leaves the composite alphabet outside +its proof. The prime-phase pilot application in PR2855 supplies the exact +recovery context. Their original files and credit remain unchanged. +Kronecker's theorem, cyclotomic irreducibility, cyclotomic field degrees +and the prime-power reduction are classical. Richard Stanley's +[Algebraic Combinatorics, Theorem 12.14](https://math.mit.edu/~rstan/algcomb/algcomb.pdf) +and Eric Moorhouse's +[Cyclotomic Fields with Applications](https://ericmoorhouse.org/handouts/cyclotomic_fields.pdf) +are accessible mathematical precedents for the integrality argument. +The proof above supplies the actual implication used here. + +The contribution is the stated extension of this project's completion +interface and its exact finite corroboration. Global literature priority, +independent human and formal proof-kernel review are unclaimed. More than +one missing column, approximate data, physical preparation, paid consumption, +supplier admission and complete multiplication-theorem obligations remain +outside scope. No new kappa or selected-frontier change follows. diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/README.md b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/README.md new file mode 100644 index 0000000000..1c9d65a78f --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/README.md @@ -0,0 +1,124 @@ +# One-column completion over two-prime odd alphabets + +This scoped proof was produced by Nick Petalas. Apache-2.0. + +Let `m = p^a q^b`, where `p, q` are distinct odd primes and `a, b` are positive. +Let `A` be an `n`-by-`(n-1)` matrix with entries in the `m`th roots of unity +and `A* A = nI`. If `3 <= n < pq` and either prime divides `n`, the unique +normalized missing column uses only `m`th roots. It preserves every supplied +column. For example, at alphabet order 15 this covers row counts 5, 6, 9, 10, +and 12 in addition to 3. + +The proof gives a separate sufficient condition at any `n >= 3`. Project each +entry to one prime-power component in its unique factorization into a +`p^a`th root and a `q^b`th root. If that projection preserves column +orthogonality, the missing column uses the original alphabet. + +## Proof + +Write `P = p^a` and `Q = q^b`. By symmetry, use the projection `pi` that sends +`x y` to `x` for `x` a `P`th root and `y` a `Q`th root. Denote the +projected matrix by `B = pi(A)`. + +**Orthogonality below `pq`.** For any two distinct columns of `A`, their +inner product is a vanishing sum of `n` roots with repetitions allowed. +Lam and Leung show that every such sum over this alphabet splits into +rotated prime cycles. If there are `r` `p`-cycles and `s` `q`-cycles, then +`n = pr + qs`. When `p` divides `n`, it divides `s`. A positive `s` +would give `n >= pq`, so all cycles have length `p`. The projection sends +each rotated `p`-cycle to a rotated `p`-cycle, which still sums to zero. +The projection commutes with phase inversion, so these are exactly the +off-diagonal column inner products of `B`. The diagonal entries stay +`n` because each projected entry has modulus one. +[Lam and Leung, Theorem 3.3 and Corollary 3.4](https://arxiv.org/pdf/math/9511209#page=7) + +**Removing the sign.** Use the normalized missing columns +`w = (nI - AA*) e_1` and `v = (nI - BB*) e_1` from PR #5865. +That result gives `w_i` among the `2m`th roots and, because `B` uses an +odd prime-power alphabet with `n >= 3`, it gives `v_i` among the `P`th roots. +Thus `w_i = eps x y` for `eps` equal to 1 or -1 and roots `x, y` of orders +dividing `P, Q`, respectively. [PR #5865](../cyclotomic-column-completion/PROOF.md) + +Let `X, Y` represent primitive roots of orders `P, Q`. The ring of integers +generated by these roots has the presentation +`Z[X,Y]/(Phi_P(X), Phi_Q(Y))`. The monic relations give a basis of +`phi(P) phi(Q)` powers, and these powers are independent over the rationals +because the roots generate the cyclotomic field of degree +`phi(PQ) = phi(P) phi(Q)`. + +Reduce coefficients modulo `q` and send `Y` to 1. This gives a ring map +to `F_q[X]/(Phi_P(X))` because `Phi_Q(1) = q`. It sends each entry of +`A` to the same residue as the corresponding entry of `B`, including +after conjugation since conjugation inverts the roots. The column formulas +therefore give the same residue for `w_i` and `v_i`. + +In the residue ring the class of `X` generates a group of odd order dividing +`P`, since `X^P = 1`. The element `-1` has order two because the +ring has odd characteristic. The residues of the `P`th roots and their +negatives lie in disjoint cosets. The equal residues of `w_i` and `v_i` +force `eps = 1`. This proves the sufficient condition and, with the first +step, the row-count theorem. + +## Exact examples + +The first fixture has row and column indices `(r,s)` and `(j,k)` +in `{0,1,2}^2`. Its entry is +`zeta_3^(rj+sk+sj) zeta_5^(sj)`. If two column indices differ in `j`, +the sum over `r` vanishes. With equal `j` and different `k`, the sum over +`s` vanishes. Both arguments survive projection to the third roots. +The cross ratio on rows `(0,0),(0,1)` and columns `(0,0),(1,0)` +has order 15, so the mixed phases cannot all be removed by row and +column scalings into either prime-power alphabet. + +The verifier uses integer power bases modulo the two cyclotomic polynomials. +It checks 6 mixed fixtures, all 86 single-column erasures, and all 1,574 +recovered entries and their opposite signs. The fixtures include order 225 +and a 25-row order-15 example for which the sufficient condition applies +outside the automatic row-count range. The two projection controls use +an eight-term sum of one 3-cycle and one 5-cycle, and the 15-row partial +Fourier tensor. The latter retains a collision under either projection +and marks where the automatic projection argument can fail. It has an +original-alphabet completion. + +## Reproduce + +Run from the repository root with CPython 3.12.15 and its standard library. + +```sh +python3.12 -I -W error -B research/two-prime-column-completion/verify.py +python3.12 -I -W error -O -B research/two-prime-column-completion/verify.py +python3.12 -B scripts/research_package.py --package research/two-prime-column-completion +python3.12 -B scripts/check_research_commit.py --package research/two-prime-column-completion --check-source-history +``` + +The direct checks print `PASS_TWO_PRIME_COLUMN_COMPLETION`. The verifier uses +fixed inputs of at most 25 rows and 25 columns. Its coefficient tables have +at most 120 entries and its exponents are reduced modulo fixed prime powers. +Python allocates these bounded objects and dispatches their operations at +runtime. No runtime source files, external dependencies, or generated files +are needed. Both registered modes keep the mathematical checks active. + +## Scope and credit + +This is an exact algebraic result for one missing column. Physical execution, +precision for inexact inputs, a paid supplier and independent human and +formal proof-kernel review remain open. No selected cold replay, Lean or +Docker run was needed for the scoped claim. It yields no new κ. + +Credit David Ganz for the prime-order setting and pilot recovery application +in PRs #2849 and #2855. PR #5865 supplies the normalized column formula, the +doubled-alphabet result, the prime-power sign result and the open odd-composite +question. Lam and Leung supply the two-prime decomposition of vanishing sums. +The new step combines a complex orthogonality-preserving projection with +reduction at the discarded prime. [Atlas B097](../pure-math-atlas-400/volumes/02-geometry.md#b097) +· [PR #2855](https://github.com/CrocSwap/integer-mult-bounds/pull/2855) +· [Advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19718465) + +## Open next questions + +- Resolve the mixed-cycle case at `m = 15, n = 8`. This is the first + row count where both cycle lengths fit in one vanishing column product. + Start by dephasing the first column and enumerating the remaining columns' + pairwise differences, whose multiplicities must decompose into one + 3-cycle and one 5-cycle. The root-sum control alone gives no compatible + partial matrix. diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/SOURCES.json b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/SOURCES.json new file mode 100644 index 0000000000..4b1a8b1b78 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/SOURCES.json @@ -0,0 +1,30 @@ +{ + "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/cyclotomic-column-completion/PROOF.md", + "usage": "provenance", + "git_blob": "5023cdde8762720467f708b28dabda0f0532064e", + "sha256": "b194084e203a70574397eeafae053af8e9e49d9e519aacfa112f039da2499674" + }, + { + "path": "research/pure-math-atlas-400/volumes/02-geometry.md", + "usage": "provenance", + "git_blob": "baef1e69c08c7cbd4dfd020862870fa5161afc86", + "sha256": "39fc97bdfa29337b79d1308e35df41e867ce2102d44755fd407aa09ff8352b39" + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/TASK.json b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/TASK.json new file mode 100644 index 0000000000..7fcc4e615e --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/TASK.json @@ -0,0 +1,95 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Exact one-column completion for partial Butson matrices over p^a q^b when either prime divides the row count below pq, or when a prime-power projection preserves column orthogonality.", + "scope_change_reason": "PR #5865 asks for the missing odd-composite case of an algebraic recovery interface. This work answers a row-count subcase without a selected-caller binding.", + "bottleneck_link": "An algebraic side result on exact phase recovery. No supplier or kappa improvement follows.", + "budget_minutes": 60, + "stop_rule": "Package the first verified same-alphabet theorem beyond the odd prime-power case.", + "outcome": "completed", + "evidence": "README.md proves the projection criterion and its row-count corollary. verify.py checks six mixed fixtures, all their 86 erasures and all 1574 recovered entries and their opposite signs, plus two projection controls. CPython 3.12.15 with the standard library.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Does every partial matrix at m=15 and n=8 admit original-alphabet completion?", + "why_it_matters": "This is the first dimension at that alphabet where one vanishing column product can use both prime cycles.", + "first_step": "Dephase the first column and use the one-3-cycle and one-5-cycle multiplicity constraint on all pairwise column differences.", + "blocked_by": "Mixed cycles can spoil prime-power projection. A root-sum example is not a compatible partial matrix." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/VERIFY.json b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/VERIFY.json new file mode 100644 index 0000000000..807e154f99 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Check exact mixed-alphabet column recovery, modular sign separation, and the mixed-cycle and boundary projection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Check exact mixed-alphabet column recovery, modular sign separation, and the mixed-cycle and boundary projection controls." + } + ] +} diff --git a/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/verify.py b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/verify.py new file mode 100644 index 0000000000..f44c327017 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/retained/two-prime/verify.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 +"""Check the two-prime completion proof on fixed exact examples.""" + +from itertools import combinations, product + + +def require(condition, message): + if not condition: + raise ArithmeticError(message) + + +def powers(prime, order): + """Sparse monomial residues modulo the prime-power cyclotomic polynomial.""" + step = order // prime + degree = order - step + residues = [((exponent, 1),) for exponent in range(degree)] + for offset in range(step): + residues.append(tuple((offset + j * step, -1) for j in range(prime - 1))) + return degree, tuple(residues) + + +def evaluate(phases, bases): + """Sum roots in the tensor product of the two integral power bases.""" + (x_degree, x_powers), (y_degree, y_powers) = bases + coefficients = [[0] * y_degree for _ in range(x_degree)] + for x, y in phases: + for i, a in x_powers[x % len(x_powers)]: + for j, b in y_powers[y % len(y_powers)]: + coefficients[i][j] += a * b + return tuple(map(tuple, coefficients)) + + +def pairing(left, right, bases): + differences = ((a - c, b - d) for (a, b), (c, d) in zip(left, right, strict=True)) + return evaluate(differences, bases) + + +def orthogonal_columns(matrix, bases): + zero = evaluate((), bases) + return all(pairing(left, right, bases) == zero + for left, right in combinations(zip(*matrix, strict=True), 2)) + + +def project(matrix, keep=0): + return tuple(tuple((x, 0) if keep == 0 else (0, y) for x, y in row) + for row in matrix) + + +def normalized_column(partial, bases): + n = len(partial) + column = [] + for index, row in enumerate(partial): + gram_row = pairing(row, partial[0], bases) + coefficients = [list(-value for value in power_row) for power_row in gram_row] + coefficients[0][0] += n if index == 0 else 0 + column.append(tuple(map(tuple, coefficients))) + return tuple(column) + + +def reduce_at_q(coefficients, q): + return tuple(sum(row) % q for row in coefficients) + + +def check_erasures(matrix, bases, q): + projected = project(matrix) + require(orthogonal_columns(matrix, bases), "mixed fixture is not orthogonal") + require(orthogonal_columns(projected, bases), "fixture loses projected orthogonality") + n = len(matrix) + entries = 0 + for erased in range(n): + partial = tuple(row[:erased] + row[erased + 1:] for row in matrix) + column = normalized_column(partial, bases) + projected_column = normalized_column(project(partial), bases) + x0, y0 = matrix[0][erased] + for index, row in enumerate(matrix): + x, y = row[erased] + expected = evaluate(((x - x0, y - y0),), bases) + require(column[index] == expected, "reconstruction changed the erased phase") + require(projected_column[index] == evaluate(((x - x0, 0),), bases), + "projected reconstruction changed the retained prime-power phase") + residue = reduce_at_q(projected_column[index], q) + require(reduce_at_q(column[index], q) == residue, "reduction mismatch") + opposite = tuple(-value % q for value in reduce_at_q(expected, q)) + require(residue != opposite, "the opposite sign also passed reduction") + entries += 1 + return n, entries + + +def mixed_fixture(p, p_power): + """Fourier blocks with a column-block-dependent row phase.""" + indices = tuple(product(range(p), repeat=2)) + matrix = tuple( + tuple(((p_power // p) * (r * j + s * k) + s * j, s * j) + for j, k in indices) + for r, s in indices + ) + # At rows (0,0),(0,1) and columns (0,0),(1,0), the cross ratio + # has exponent one in each component, even after row and column gauges. + require(matrix[0][0] == matrix[0][p] == matrix[1][0] == (0, 0), + "mixed cross-ratio normalization changed") + require(matrix[1][p] == (1, 1), "fixture lacks a primitive mixed cross ratio") + return matrix + + +def check_projection_boundaries(): + bases = powers(3, 3), powers(5, 5) + mixed_cycles = tuple((i, 0) for i in range(3)) + tuple((0, j) for j in range(5)) + require(evaluate(mixed_cycles, bases) == evaluate((), bases), + "the two mixed cycles must vanish together") + collapsed = tuple((x, 0) for x, _ in mixed_cycles) + require(evaluate(collapsed, bases) == evaluate(((0, 0),) * 5, bases), + "the five-cycle should contribute five after projection") + + indices = tuple(product(range(3), range(5))) + partial = tuple(tuple((r * j, s * k) for j, k in indices[:-1]) for r, s in indices) + require(orthogonal_columns(partial, bases), "boundary partial Fourier matrix is invalid") + zero = evaluate((), bases) + for kept_part, discarded_phase in ((0, (0, 1)), (1, (1, 0))): + columns = tuple(zip(*project(partial, keep=kept_part), strict=True)) + left = columns[0] + right = columns[indices.index(discarded_phase)] + require(pairing(left, right, bases) != zero, + "discarded prime did not collapse two columns") + + +def main(): + fixtures = ( + (3, 5, 3, 5), + (3, 5, 9, 5), + (3, 5, 3, 25), + (3, 5, 9, 25), + (5, 7, 5, 7), + (5, 3, 5, 3), + ) + erasures = 0 + entries = 0 + for p, q, p_power, q_power in fixtures: + bases = powers(p, p_power), powers(q, q_power) + fixture_erasures, fixture_entries = check_erasures(mixed_fixture(p, p_power), bases, q) + erasures += fixture_erasures + entries += fixture_entries + check_projection_boundaries() + print("PASS_TWO_PRIME_COLUMN_COMPLETION") + print(f"{len(fixtures)} mixed fixtures, {erasures} erasures, {entries} recovered entries") + print("All opposite signs reject modulo q. Mixed-cycle and pq-row controls pass.") + + +if __name__ == "__main__": + main() diff --git a/research/fifteenth-root-column-capacity/retained/source7762/verify.py b/research/fifteenth-root-column-capacity/retained/source7762/verify.py new file mode 100644 index 0000000000..7fe9f369d1 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7762/verify.py @@ -0,0 +1,281 @@ +"""Check the mixed-cycle column obstruction with exact integer arithmetic. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from hashlib import sha1, sha256 +from itertools import combinations, combinations_with_replacement, product +import json +from math import comb, isqrt +from pathlib import Path +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent + + +def require(value, message): + if not value: + raise ArithmeticError(message) + + +def third_sum(exponents): + counts = [0, 0, 0] + for exponent in exponents: + counts[exponent % 3] += 1 + return counts[0] - counts[2], counts[1] - counts[2] + + +def edge_word(n, edge): + a, b = edge + return tuple(1 if i == a else 2 if i == b else 0 for i in range(n)) + + +def compatible(a, b): + return a[0] == b[0] or a[1] == b[1] or a == b[::-1] + + +def gram_determinant(n, q, phase): + twice_real = 2 if phase % 3 == 0 else -1 + return n ** 3 - 3 * n * q ** 2 + q ** 3 * twice_real + + +def add(a, b): + return a[0] + b[0], a[1] + b[1] + + +def multiply(a, b): + x, y = a + u, v = b + return x * u - y * v, x * v + y * u - y * v + + +def conjugate(a): + return a[0] - a[1], -a[1] + + +def matrix_gram(matrix, use_conjugate=True): + return [[sum_pair(multiply(a, conjugate(b) if use_conjugate else b) + for a, b in zip(left, right)) for right in matrix] + for left in matrix] + + +def sum_pair(values): + result = (0, 0) + for value in values: + result = add(result, value) + return result + + +def check_spectral_identity(): + qmatrix = [[1, 2, 3], [2, 1, 4], [3, 4, 1]] + square = [[sum(qmatrix[i][k] * qmatrix[k][j] for k in range(3)) + for j in range(3)] for i in range(3)] + expected = [[(square[i][j] - 3 * qmatrix[i][j] + 3 * (i == j), 0) + for j in range(3)] for i in range(3)] + for phase in ((0, 1), (-1, -1)): + shift = add(phase, (-1, 0)) + matrix = [[add((qmatrix[i][j], 0), shift if i == j else (0, 0)) + for j in range(3)] for i in range(3)] + require(matrix_gram(matrix) == expected, 'Hermitian spectral identity') + require(matrix_gram(matrix, False) != expected, 'conjugation fault') + wrong = [[add((qmatrix[i][j], 0), phase if i == j else (0, 0)) + for j in range(3)] for i in range(3)] + require(matrix_gram(wrong) != expected, 'diagonal shift fault') + wrong_coefficient = [[(square[i][j] - qmatrix[i][j] + 3 * (i == j), 0) + for j in range(3)] for i in range(3)] + require(expected != wrong_coefficient, 'linear coefficient fault') + return {'orientations': 2, 'entries_per_orientation': 9, + 'faults': ['conjugation', 'diagonal shift', 'linear coefficient']} + + +def maximal_cliques(adjacency): + result = [] + + def visit(chosen, possible, excluded): + if not possible and not excluded: + result.append(tuple(chosen)) + return + union = possible | excluded + pivot = max(union, key=lambda i: len(possible & adjacency[i])) + for vertex in sorted(possible - adjacency[pivot]): + visit(chosen + [vertex], possible & adjacency[vertex], + excluded & adjacency[vertex]) + possible.remove(vertex) + excluded.add(vertex) + + visit([], set(range(len(adjacency))), set()) + return sorted(tuple(sorted(row)) for row in result) + + +def check_edges(): + n = 8 + words = {word for word in product(range(3), repeat=n) + if third_sum(word) == (5, 0)} + edges = list((a, b) for a in range(n) for b in range(n) if a != b) + require(words == {edge_word(n, edge) for edge in edges}, 'word inventory') + adjacency = [set() for _ in edges] + pair_checks = 0 + for i, j in combinations(range(len(edges)), 2): + left, right = edge_word(n, edges[i]), edge_word(n, edges[j]) + actual = third_sum(b - a for a, b in zip(left, right)) == (5, 0) + require(actual == compatible(edges[i], edges[j]), 'edge compatibility') + if actual: + adjacency[i].add(j) + adjacency[j].add(i) + pair_checks += 1 + cliques = maximal_cliques(adjacency) + stars = {tuple(i for i, edge in enumerate(edges) if edge[axis] == centre) + for axis in range(2) for centre in range(n)} + reverse = {tuple(sorted((edges.index((a, b)), edges.index((b, a))))) + for a, b in combinations(range(n), 2)} + require(set(cliques) == stars | reverse, 'maximal clique classification') + six = {sub for star in stars for sub in combinations(star, 6)} + direct_six = set() + + def enumerate_six(chosen, possible): + if len(chosen) == 6: + direct_six.add(tuple(chosen)) + return + while possible: + vertex = min(possible) + possible.remove(vertex) + enumerate_six(chosen + [vertex], possible & adjacency[vertex]) + + enumerate_six([], set(range(len(edges)))) + require(six == direct_six and len(six) == 112, 'six-edge coverage') + records = [] + for clique in sorted(six): + columns = [(0,) * n] + [edge_word(n, edges[i]) for i in clique] + unused = [r for r in range(n) if all(col[r] == 0 for col in columns)] + require(len(unused) == 1, 'unique unused row') + reference = unused[0] + residues = [] + for r in range(n): + residue = (1, 0) if r == reference else tuple( + -x % 5 for x in third_sum(col[r] for col in columns)) + roots = [tuple(x % 5 for x in third_sum([e])) for e in range(3)] + negatives = [tuple(-x % 5 for x in root) for root in roots] + require(residue in roots and residue not in negatives, 'completion sign') + residues.append(roots.index(residue)) + records.append({'edges': [list(edges[i]) for i in clique], 'reference': reference, + 'completion_mod_five': residues}) + return {'ternary_words_examined': 3 ** n, 'edge_words': len(edges), + 'pair_checks': pair_checks, 'maximal_cliques': len(cliques), + 'stars': len(stars), 'reverse_pairs': len(reverse), + 'partial_configurations': records} + + +def check_root_sums(): + # Phi_15(X) = X^8-X^7+X^5-X^4+X^3-X+1. + phi = (1, -1, 0, 1, -1, 1, 0, -1) + powers = [] + current = [1] + [0] * 7 + for _ in range(15): + powers.append(tuple(current)) + leading = current[-1] + current = [0] + current[:-1] + current = [a - leading * b for a, b in zip(current, phi)] + require(current == [1] + [0] * 7, 'fifteenth power') + expected = {tuple(sorted(tuple((a + 5 * i) % 15 for i in range(3)) + + tuple((b + 3 * j) % 15 for j in range(5)))) + for a in range(5) for b in range(3)} + actual = set() + examined = 0 + for terms in combinations_with_replacement(range(15), 8): + examined += 1 + total = tuple(sum(powers[e][i] for e in terms) for i in range(8)) + if total == (0,) * 8: + actual.add(terms) + require(actual == expected, 'complete eight-term vanishing sums') + require(examined == comb(22, 8), 'multiset coverage') + for terms in actual: + projected = third_sum(terms) + require(projected in ((5, 0), (0, 5), (-5, -5)), 'projected mixed sum') + return {'multisets_examined': examined, 'vanishing_multisets': [list(row) for row in sorted(actual)]} + + +def check_general_steps(): + primes = [q for q in range(5, 102) if all(q % d for d in range(2, isqrt(q) + 1))] + phase_records = [] + sign_rows = 0 + for q in primes: + n = q + 3 + solutions = [(r, s) for r in range(n // 3 + 1) for s in range(n // q + 1) + if 3 * r + q * s == n] + require(solutions == [(1, 1)], 'mixed cycle count') + balanced = 0 + for a, b, c in product(range(3), repeat=3): + phase = (a + c - b) % 3 + determinant = gram_determinant(n, q, phase) + require((determinant >= 0) == (phase == 0), 'Gram phase rigidity') + balanced += phase == 0 + require(balanced == 9, 'balanced triangle count') + roots = [tuple(x % q for x in third_sum([e])) for e in range(3)] + require(not set(roots) & {tuple(-x % q for x in root) for root in roots}, + 'sign cosets') + for orientation in (1, 2): + columns = [(0,) * n] + [tuple(orientation if r == 0 else + -orientation % 3 if r == j else 0 for r in range(n)) + for j in range(1, n - 1)] + for r in range(n - 1): + residue = tuple(-x % q for x in third_sum(col[r] for col in columns)) + require(residue in roots, 'general completion residue') + sign_rows += 1 + discriminant = 9 + 4 * q + require(discriminant % 8 == 5 and isqrt(discriminant) ** 2 != discriminant, + 'spectral irrationality') + for multiplicity in range(n + 1): + require((2 * multiplicity - n) ** 2 * discriminant != n ** 2, + 'trace multiplicity contradiction') + phase_records.append({'q': q, 'rows': n, 'balanced_determinant': + gram_determinant(n, q, 0), 'unbalanced_determinant': + gram_determinant(n, q, 1), 'discriminant': discriminant}) + # A reverse pair passes pair compatibility but cannot form a three-edge star. + require(compatible((0, 1), (1, 0)), 'reverse-pair positive control') + require(not any(compatible((0, 1), edge) and compatible((1, 0), edge) + for edge in product(range(8), repeat=2) + if edge[0] != edge[1] and edge not in ((0, 1), (1, 0))), + 'reverse-pair extension control') + require(gram_determinant(8, 5, 1) == -213, 'unbalanced phase control') + require(third_sum([0] * 6 + [1, 2]) == (5, 0), 'projection is not orthogonal') + require((1, 0) != tuple(-x % 5 for x in (1, 0)), 'negative sign control') + require(gram_determinant(6, 3, 1) > 0, 'excluded q=3 phase boundary') + return {'primes': phase_records, 'triangle_cases': 27 * len(primes), + 'sign_rows': sign_rows, + 'controls': ['reverse pair', 'nontrivial triangle phase', + 'nonorthogonal projection', 'opposite completion sign', + 'excluded q=3 boundary'], + 'spectral_identity': check_spectral_identity()} + + +def sources(): + pins = json.loads((ROOT / 'SOURCE-PINS.json').read_text())['sources'] + for pin in pins: + data = (ROOT / pin['retained']).read_bytes() + require(sha256(data).hexdigest() == pin['sha256'], 'retained SHA256') + require(sha1(b'blob ' + str(len(data)).encode() + b'\0' + data).hexdigest() + == pin['git_blob'], 'retained Git blob') + command = [sys.executable, '-W', 'error', *(['-O'] if sys.flags.optimize else []), + '-B', str(ROOT / 'retained/two-prime/verify.py')] + replay = subprocess.run(command, check=True, text=True, capture_output=True, timeout=30) + require('PASS_TWO_PRIME_COLUMN_COMPLETION' in replay.stdout, 'source replay') + return len(pins) + + +def collect(): + return {'source_files': sources(), 'root_sums': check_root_sums(), + 'eight_row_projection': check_edges(), 'general_steps': check_general_steps()} + + +def main(): + actual = collect() + expected = json.loads((ROOT / 'RESULT.json').read_text()) + require(actual == expected, 'saved certificate mismatch') + print('PASS_MIXED_CYCLE_COLUMN_OBSTRUCTION') + print('319770 root multisets; 15 vanishing sums; 6561 ternary words; 1540 edge pairs') + print('44 maximal cliques; all 112 six-edge configurations; exact sign and trace controls') + print('No (q+3)-by-(q+2) input over roots of order 3q^b, q prime >=5: written proof') + + +if __name__ == '__main__': + main() diff --git a/research/fifteenth-root-column-capacity/retained/source7768/CREDITS.md b/research/fifteenth-root-column-capacity/retained/source7768/CREDITS.md new file mode 100644 index 0000000000..ba7ae62d84 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7768/CREDITS.md @@ -0,0 +1,33 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared the new 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. + +Ali Romman supplied the projected-star classification and mixed-case +obstruction in [PR #7762](https://github.com/CrocSwap/integer-mult-bounds/pull/7762). +Its [proof](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/PROOF.md) +and [checker](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/verify.py) +are retained with all source notices and inputs. All sixteen files are +byte-exact under `retained/source7762/`. + +Nick Petalas (@petalas) supplied the two-prime projection and the +released mixed-cycle question in +[PR #7744](https://github.com/CrocSwap/integer-mult-bounds/pull/7744). +The [source proof and question](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/README.md) +and [prime-power arithmetic](https://github.com/petalas/integer-mult-bounds/blob/7dc85513e8ee9b771a5856f027cf199936f85af0/research/two-prime-column-completion/verify.py) +remain unchanged. The new checker reuses that arithmetic. The source +also retains Nick's completion theorem and its credit to David Ganz; +those notices remain intact. Completion is not needed for the new +rectangular argument, but its source check is still replayed. + +T. Y. Lam and K. H. Leung supplied the classical cycle theorem in +[On Vanishing Sums of Roots of Unity, Theorem 3.3 and Corollary 3.4](https://arxiv.org/pdf/math/9511209#page=7). +The classical quadratic-subfield fact is stated and proved in +[Romyar Sharifi's Algebraic Number Theory, Lemma 3.2.2](https://www.math.ucla.edu/~sharifi/notes/algnum-ch03.html). +The new result applies these facts to the rectangular rank defect, +then excludes equality through row orthogonality. No global +literature-priority claim is made. + +`SOURCE-PINS.json` authenticates retained bytes. `SOURCES.json` records +canonical main provenance. A source pin does not assert ancestry. diff --git a/research/fifteenth-root-column-capacity/retained/source7768/PROOF.md b/research/fifteenth-root-column-capacity/retained/source7768/PROOF.md new file mode 100644 index 0000000000..88f7de6041 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7768/PROOF.md @@ -0,0 +1,183 @@ +# A strict column-defect bound + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Let q>=5 be prime, b>=1, n=q+3 and 1<=m<=n. Suppose that A is an +n-by-m matrix over the roots of order 3q^b and A* A=nI. Set d=n-m. +Then + +```text +m^2 < d^2(4d-3). +``` + +This is a necessary condition, not an existence theorem. It excludes an +eight-by-six matrix for every alphabet of order 3*5^b. It strengthens the +n-by-(n-1) obstruction in [PR #7762](https://github.com/CrocSwap/integer-mult-bounds/pull/7762). +At q=101 it excludes 91 columns in 104 rows; the strict inequality is +needed in this example. No physical supplier or new kappa follows. + +## 1. The rectangular Hermitian block + +Write omega for a primitive third root and eta for a primitive q^bth +root. The m<=3 case satisfies the bound directly: n>=8 gives d>=5. +Assume m>=4 from now on. + +The projected-star proof in +[the pinned source, Section 1](https://github.com/aliromman/integer-mult-bounds/blob/d33fe8562c86888307cbba4a2aa92490212c8d78/research/mixed-cycle-column-obstruction/PROOF.md) +applies without the n-1-column restriction. Here are the required steps. +Every zero column inner product has length q+3. The two-prime cycle +theorem makes it one 3-cycle and one q-cycle, because 3r+qs=q+3 has +only the solution r=s=1 in nonnegative integers. Discarding the eta +component gives projected Gram diagonal n and off-diagonal q times a +third root. An unbalanced triangle has determinant -3q^3+27q+27<0. +Thus column phases make every off-diagonal projected Gram entry q. +[Lam and Leung, Theorem 3.3 and Corollary 3.4](https://arxiv.org/pdf/math/9511209#page=7) + +Make the first projected column constant. Each other column then has +omega at one row, omega squared at another, and 1 elsewhere. Two such +ordered pairs are compatible exactly when they have the same first +row, the same second row, or are reverses. A reverse pair admits no +third pair. At least three pairs therefore form one directed star. +Its m-1 leaves and centre use m rows; d rows remain unused. + +If the centre exponent is s, multiply its row by omega^(-s). Order the +used rows so that the constant column matches the centre, and each +other column matches its leaf. The projected top m-by-m block has +omega^(-s) on its diagonal and 1 elsewhere. All bottom entries are 1. +Scale columns by eta powers to make every top diagonal q-part 1. +These operations preserve the alphabet and column orthogonality. Write + +```text +A = Q + lambda E, Q = [ K ], E = [ I_m ], + [ R ] [ 0 ] +lambda = omega^(-s)-1. +``` + +K is m-by-m, R is d-by-m, all their entries are q^bth roots, and K_ii=1. +For columns i,j, the only two terms with a nontrivial third-root part +occur at rows i,j. The unique 3-cycle must contain both with equal +q-parts. These q-parts are K_ij and conjugate(K_ji), so K is Hermitian. +As lambda+conjugate(lambda)=-3 and |lambda|^2=3, orthogonality gives + +```text +K^2 - 3K - qI = -R*R. (1) +``` + +In particular, the left side has rank at most d. No completion formula +or extra missing columns were assumed. + +## 2. Equal quadratic-root multiplicities + +Put F=Q(eta), Delta=4q+9 and p(t)=t^2-3t-q. Delta is 5 modulo 8, +so it is not a rational square; also q does not divide Delta. +The unique quadratic subfield of Q(zeta_q) is Q(sqrt(q*)), where +q*=(-1)^((q-1)/2)q. See +[Sharifi, Algebraic Number Theory, Lemma 3.2.2](https://www.math.ucla.edu/~sharifi/notes/algnum-ch03.html). +The extension F/Q(zeta_q) has odd degree q^(b-1). A quadratic subfield +of F must therefore lie in Q(zeta_q): its compositum with that field +would otherwise have degree two in an odd-degree extension. + +The q-adic valuation of Delta is zero, while that of q* is one. +Their ratio cannot be a rational square. Thus Q(sqrt(Delta)) is not +this quadratic subfield, and p is irreducible over F. + +The characteristic polynomial of K lies in F[t]. The two roots of p +have the same multiplicity k in it. K is Hermitian, so it is +diagonalizable. Let h=m-2k count its other eigenvalues. Equation (1) +gives h<=d. Each entry of K has modulus one, so + +```text +trace(K) = m, trace(K^2) = m^2. +``` + +The sum and squared sum of the other h real eigenvalues are therefore + +```text +T = m-3k = (3h-m)/2, +E2 = m^2-k(2q+9) = m^2-(m-h)(2n+3)/2. +``` + +Cauchy's inequality gives T^2<=h E2. This also holds when h=0, +where both actual sums must be zero. After multiplication by four, + +```text +F(h) = (4n-3)h^2 - 4mdh - m^2 >= 0. (2) +``` + +If d=0, h=0 contradicts F(0)=-m^2. Thus d>0. On [0,d], F is convex +and F(0)<0. Equation (2) implies F(d)>=0. Equivalently, + +```text +m^2 <= d^2(4d-3). (3) +``` + +For a direct check, the chord excess is + +```text +h F(d) + (d-h) F(0) - d F(h) + = (4n-3)d h(d-h) >= 0. +``` + +## 3. Equality is impossible + +Suppose equality holds in (3). The strict chord inequality in the +interior, and F(0)<0, force h=d and equality in Cauchy. All h remaining +eigenvalues of K are one common value + +```text +beta = (3d-m)/(2d), p(beta) = -m. +``` + +The second identity follows from m^2=d^2(4d-3) and q=m+d-3. +Equation (1) now says that `R*R` has nonzero eigenvalue m with +multiplicity d. Thus `RR*=mI_d`. The bound forces d>=2, so two rows of +R give a zero sum of m roots of order q^b. + +Such a zero sum has length divisible by q. One direct proof writes +its multiplicities in a polynomial f of degree less than q^b. Since +Phi_(q^b) divides f, f(1) is divisible by Phi_(q^b)(1)=q. Hence q|m +and q|(d-3). But m>=4 gives 0<=d<=q-1, so this forces d=3. Equality +then gives m=9 and q=m+d-3=9, contrary to primality. This proves the +strict bound. + +At q=101, the non-strict spectral relaxation allows m=91,d=13, +k=39 and beta=-2. The row-orthogonality argument removes that case. +Thus the strict conclusion is stronger than the trace relaxation. + +## Evidence and limits + +The checker authenticates all sixteen retained source files and runs +the PR7762 verifier unchanged, including its PR7744 replay. New exact +checks use the retained prime-power cyclotomic basis arithmetic. +There are 36 rectangular fixtures: q in {5,7,11}, b in {1,2}, +m in {4,n-1,n}, and both star orientations. All 2,828 Gram entries +agree with (1), including nonempty and empty R blocks. Four altered +formulas fail. Synthetic block fixtures test the identity; they are +not claimed to be orthogonal examples of A. + +The three polynomial identities have degree at most four in each +variable. They agree on a five-point grid in each variable, which +determines every coefficient over Q. This verifies all coefficients, +not only a sampled numerical inequality. Separate integer calculations +check all 11,193 possible multiplicity cases for the 24 primes from +5 through 101. They recover the strict equality control above. +A union of one 3-cycle and one q-cycle gives a valid two-column +positive control in each fixture alphabet; deleting a term fails. + +| q | Rows | Minimum defect from this bound | Maximum columns from this bound | +| --- | --- | --- | --- | +| 5 | 8 | 3 | 5 | +| 7 | 10 | 3 | 7 | +| 11 | 14 | 4 | 10 | +| 13 | 16 | 4 | 12 | +| 17 | 20 | 5 | 15 | +| 101 | 104 | 14 | 90 | + +The general theorem is the written argument. It uses the classical +cycle and quadratic-subfield theorems. The finite checks do not replace +these inputs. The upper bounds need not be attained. Other row counts, +larger powers of three, more prime factors, approximate orthogonality, +physical preparation and complete caller pricing remain open. +All five framework assumptions remain. No selected cold replay, +Lean, Docker, independent human acceptance or formal proof kernel was +used. No global literature priority is claimed. diff --git a/research/fifteenth-root-column-capacity/retained/source7768/README.md b/research/fifteenth-root-column-capacity/retained/source7768/README.md new file mode 100644 index 0000000000..82a0784318 --- /dev/null +++ b/research/fifteenth-root-column-capacity/retained/source7768/README.md @@ -0,0 +1,36 @@ +# A strict mixed-cycle column bound + +For n=q+3 rows over roots of order 3q^b, where q>=5 is prime and b>=1, +any m orthogonal columns satisfy m^2 1: + require(all(len(adjacency[v]) == 2 for v in component), 'six-cycle degrees') + triangles = [(i, j, k) for i, j, k in combinations(range(len(vertices)), 3) + if j in adjacency[i] and k in adjacency[i] and k in adjacency[j]] + require(not triangles, 'complete triangle enumeration') + masks = [sum(1 << j for j in neighbors) for neighbors in adjacency] + require(all(masks[i] & masks[j] == 0 for i, j in edges), 'independent common-neighbor check') + for word in vertices: + require(residue(a - a for a in word) == (8,) + (0,) * 7, 'self-column norm') + columns = [(0,) * 8, SECOND, vertices[edges[0][0]], vertices[edges[0][1]]] + for i, j in product(range(4), repeat=2): + difference = [a - b for a, b in zip(columns[i], columns[j], strict=True)] + require(residue(difference) == ((8,) + (0,) * 7 if i == j else zero), 'attaining Gram') + require((tensor_residue(difference) == zero) == (i != j), 'attaining tensor Gram') + mutations = 0 + for column, row, change in product(range(4), range(8), range(1, 15)): + altered = list(columns[column]) + altered[row] = (altered[row] + change) % 15 + other = columns[(column + 1) % 4] + require(residue(a - b for a, b in zip(altered, other, strict=True)) != zero, + 'one-entry change escaped Gram check') + mutations += 1 + return {'vertices': vertices, 'edges': edges, 'components': components, + 'pair_checks': comb(len(vertices), 2), 'triple_checks': comb(len(vertices), 3), + 'maximal_three_column_sets': 83, 'maximal_four_column_sets': 12, + 'attaining_matrix_rows': list(zip(*columns, strict=True)), + 'single_entry_mutations_rejected': mutations, + 'wrong_bilinear_edge_count': len(wrong_edges)} + + +def collect(): + count = source_check() + vertices, enumeration = enumerate_columns() + return {'source_files': count, 'exact_capacity': 4, + 'enumeration': enumeration, 'extension_graph': graph_check(vertices)} + + +def main(): + actual = collect() + expected = json.loads((ROOT / 'RESULT.json').read_text()) + require(json.loads(json.dumps(actual)) == expected, 'saved certificate mismatch') + print('PASS_FIFTEENTH_ROOT_COLUMN_CAPACITY') + print('Exact maximum: four orthogonal columns in eight rows over fifteenth roots') + print('116280 tail multisets; two enumerations of 20160 normalized columns; 95 extensions') + print('4465 pairs; 138415 triples; graph = two six-cycles and 83 isolated vertices') + print('Twelve normalized four-column sets; exact attaining Gram; 448 changed entries reject') + + +if __name__ == '__main__': + main()