OMEGA PAPER IX — FOLLOW-UP COVER SEARCH
Checkpoint: 1 November 2026

CONCLUSION

The certified integer-width interval remains 307 <= ell* <= 352 bits.
This search did not improve the 352-bit upper endpoint and did not compute
F_max. The 13-coordinate closed-neighborhood cover remains stronger than the
additional orbit covers tested here. The new calculations are useful negative
results about those particular projection-volume certificates; they do not
rule out a 351-bit proof by a different cover or method.

The fixed construction is unchanged: M=13I+A on the pinned 600-cell graph,
Q=339949771344778, S=10^15, D=25S, B={0,...,73}^120,
Delta=det(M), and F_max=max_c #{u in B:[u]=c}. For a coordinate block W of
size m whose 120 left translates form an exact m-cover, the continuous
uniform-cover inequality gives

    F_max^m Delta^m <= Vol_m(pi_W([0,73]^120 + M[0,1]^120))^120.

All comparisons below use exact integer powers. Decimal bit estimates are not
used as certificates.

1. OPEN 12-COORDINATE NEIGHBORHOOD

For W=N(0), the exact low projected-volume coefficients are

    a_0,...,a_5 = [1, 300, 38784, 2874040, 136412280, 4381163616].

The permanent-bounded remaining coefficients give

    Vol_12(pi_W Z) <= 641235831648043439100541.

This candidate does not certify either 351 or 352 bits. Its exact low-order
volume alone already exceeds the 351-bit comparison threshold, so this
12-cover cannot yield a 351-bit upper bound through this volume inequality.
The full 12-dimensional projected volume was not computed.

Certificate and checker: icosahedral_neighborhood.json and
verify_icosahedral_neighborhood.py. The normal and optimized Python runs
produce byte-identical JSON.

2. DENSE 14-COORDINATE COVER

Take W={0,1,33,34,...,44}; it has 14 coordinates and 45 induced edges. Its
120 left translates are checked to form an exact 14-cover. The exact
coefficients through order six are

    a_0,...,a_6 =
    [1, 350, 53275, 4713250, 272091446, 10881492682, 311816458360].

Using permanent upper coefficients above order six gives

    Vol_14(pi_W Z) <= 5633063088368467223602652756.

The exact power comparisons certify 352 bits and fail to certify 351 bits.
An additional lower-bound calculation for a_7 enumerates all minors using
internal columns and all minors using exactly one external M-column pattern.
It proves a_7 >= 2864355250236 and hence

    Vol_14(pi_W Z) >= 5499040421986866528309640656,

which is already above the 351-bit threshold. Thus this particular 14-set
projection-volume certificate cannot prove 351 bits. This statement concerns
the strength of the bound from W; it is not a lower bound on F_max.

Checkers/results: verify_dense_14_cover.py,
verify_dense_14_order6.py, verify_dense_14_order7_lower.py,
verify_dense_14_order7_one_external.py and their JSON outputs.

3. DENSE 15-COORDINATE COVER

Take W={0,1,8,33,34,...,44}; it has 15 coordinates and 49 induced edges.
Its 120 translates form an exact 15-cover. Exact coefficients through order
six are

    a_0,...,a_6 =
    [1, 375, 61694, 5948804, 377660931, 16776444899, 540170696592].

With permanent upper coefficients above order six,

    Vol_15(pi_W Z) <= 540948764237121473875124284070.

The exact comparisons certify 352 bits but not 351 bits. The full 15D volume
and a_7 were not computed. A rowwise Cauchy-Schwarz attempt at a_7 was weaker
than the permanent bound and did not tighten this result.

Checkers/results: verify_dense_15_cover.py, verify_dense_15_order5.py,
verify_dense_15_order6.py, verify_dense_15_order7_cauchy.py and their JSON
outputs. The order-5 normal and optimized runs agree byte for byte.

4. DENSE 16-COORDINATE COVER

Take W={0,1,3,8,33,34,...,44}; it has 16 coordinates and 53 induced edges.
Its 120 translates form an exact 16-cover. Exact coefficients through order
six are

    a_0,...,a_6 =
    [1, 400, 70729, 7384460, 511583174, 25012838732, 895039527862].

The order-six permanent coefficient is 1344194913534. Bounding higher
coefficients by permanents gives

    Vol_16(pi_W Z) <= 52031364700819577657212646484774.

The exact comparisons again certify 352 bits but not 351 bits. The order-six
calculation enumerated 641562314 minor subsets over rowset-orbit
representatives, accounting for 1246081305 minor subsets after orbit
multiplicities. The full 16D volume and F_max were not computed.

Checkers/results: verify_dense_16_cover.py, verify_dense_16_order5.py,
verify_dense_16_order6.py and their JSON outputs. The order-5 normal and
optimized runs agree byte for byte; the order-six run was executed in normal
Python mode.

5. COMPARISON AND LIMITS

Exact root comparisons show that the refined 13-coordinate closed-neighborhood
upper volume has a smaller per-coordinate root than the 14-, 15-, or
16-coordinate candidates above. All four certify the same integer endpoint,
352 bits. A randomized screen of 24 other 13-sets and the 12-coordinate
neighborhood did not find a 351-bit certificate. These shape searches are not
exhaustive and prove no global optimality statement about projection covers.

No exact maximum fiber, exact collision moment, or optimal width was found.
The lower endpoint remains 307 bits. The exact maximum-fiber problem is still
the unresolved finish line.

6. EXACT SEVENTH COEFFICIENT FOR THE 13-COORDINATE COVER

The closed-neighborhood cover was extended one exact degree further. Its
seventh coefficient is

    a_7 = 3007006391716,

computed over 30 stabilizer-orbit representatives, covering 45,111,870
representative minors (2,733,293,660 after orbit multiplicities). Combining
this with the exact coefficients through a_6 gives the certified partial
volume lower bound

    Vol_13(pi_W Z) >= 57869157529977646724169246.

Its 120th-power comparison is already greater than
    (2^351 Delta)^13.
Therefore the exact 13D projection volume is too large for this particular
uniform-cover inequality to prove a 351-bit upper bound. The permanent tail
still gives the existing 352-bit certificate. Normal and optimized Python
runs produced byte-identical JSON (SHA-256
9c2142c3fc5e6d15b7f7f90255e0a700574f859e9a3ae031cb189d8c59276c6d).

7. EXACT SIXTH COEFFICIENT FOR A 17-COORDINATE COVER

The block

    W={0,1,2,5,15,33,34,...,44}

has 17 coordinates and 57 induced edges. Its 120 verified graph
automorphisms form an exact 17-cover. The exact projected-volume coefficients
through degree six are

    [1, 425, 80380, 9035206, 678562739, 36234843925, 1427863856538].

All 120 columns of the projected 17-by-120 matrix are included. The exact
permanent tail gives

    Vol_17(pi_W Z) <= 5013111833786061395384630177301042.

This proves 352 bits but fails 351 bits; its upper bound is weaker than the
13-coordinate certificate. The exact lower volume through degree six is
4554984350567732839178008696534430, which does not rule out 351 bits for this
block. The full 17D volume and F_max remain uncomputed. The exact degree-six
run used normal Python mode and enumerated 353,513,331 representative minors
(1,919,854,558 after orbit multiplicities).

8. SEVENTH-DEGREE LOWER CHECKS FOR THE 15- AND 16-COVERS

For the 15-block, the exact internal-column and one-external-column terms give

    a_7 >= 5856331288065,
    Vol_15(pi_W Z) >= 521163843376360692749708901217.

For the 16-block, the exact internal-column terms give

    a_7 >= 3314689941194,
    Vol_16(pi_W Z) >= 48797103373764458260571691737880.

Neither partial volume lower bound exceeds its 351-bit threshold. These runs
do not compute a_7 exactly and do not improve the 352-bit upper endpoint.

9. RESULT OF THE EXTENDED SEARCH

The interval remains 307 <= ell* <= 352 bits. The exact 13D and 14D partial
volumes rule out obtaining 351 through those particular coordinate-cover
inequalities; the tested 15D, 16D, 17D, and restricted 19D covers did not
produce a 351-bit upper bound. This is not a proof that every coordinate cover
fails, and it does not rule out a different geometric, Fourier, or
combinatorial method.

The exact maximum fiber, exact C_10, practical decoder, and optimal width are
still unresolved. A preliminary 17-block screen that used only internal
columns was discarded; all final 17-block certificates and bounds include
all 120 projected M columns.

10. RESTRICTED SCREEN OF 19-COORDINATE ORBIT COVERS

To test whether a larger, denser neighborhood improves the uniform-cover
bound, I enumerated every choice of six distance-two vertices added to one
closed 13-neighborhood: 906,192 candidate 19-sets. This is an exhaustive scan
of that specified family, not of all 19-subsets of the 120 vertices. Candidates
were ranked by their exact second volume coefficient and induced edge count;
the five best distinct orbits under the exact 120-element local stabilizer
were retained. For each, the 120 verified graph automorphisms give an exact
uniform 19-cover, and all 120 columns of the projected matrix were included
in the permanent upper bound.

For the best retained block

    W={0,1,2,7,8,15,33,34,...,44,89},

with 68 induced edges, the exact projected-volume coefficients through degree
four are

    [1, 475, 101349, 12972635, 1120523768].

Thus the exact partial volume lower bound is

    25131280698312420813531841016305034820,

and the permanent-tail upper bound is

    51256962105118846260766201507147311770.

The upper comparison proves 353 bits, but not 352; the lower comparison does
not exclude 351. The upper bound is also weaker than the retained 13-coordinate
cover. This screen therefore does not narrow the interval. It does show that
this particular dense-neighborhood route, within the enumerated candidate
family and with the computed coefficients, has not improved the certificate.
The full 19D projected volume, F_max, and optimal width remain uncomputed.
The run took 99.526 seconds and enumerated 4,083,160 exact minor cases for the
best candidate through degree four. Reproduce with
`python3 verify_cover19_screen.py`; its machine-readable result is
`cover19_screen_order4.json` (report SHA-256
4a712a78a9c3695747e518a2f28e6c90c18a13439b5299affc8cbed486f3c2b0).

The current certified interval remains 307 <= ell* <= 352 bits. No claim is
made that every orbit cover, every zonotope inequality, or every other method
has been exhausted.

11. SHEARER RELAXATION OF THE FULL MATCHING MAJORANT

I also tested a different use of Shearer's entropy inequality. Write the
120-dimensional zonotope volume as a sum of absolute minors of [73 I | M].
Bounding each minor by the permanent of its nonnegative submatrix gives the
weighted partial-matching sum

    Z = sum_P 73^(120-|P|) product_(i,j in P) M[i,j],

where P ranges over partial matchings in the bipartite support graph of M.
Thus Vol_120([0,73]^120 + M[0,1]^120) <= Z. Treat each row as choosing either
the unmatched symbol (weight 73) or a column j (weight M[i,j]), with all
non-unmatched choices distinct. For a uniform m-cover by 120 translates of W,
Shearer's entropy inequality and the Gibbs variational inequality give

    Z <= Z_W^(120/m),

where Z_W is the exact weighted partial-matching sum restricted to rows in W,
with all 120 columns retained. This is a valid global upper bound, but its
local matching relaxation is at least as loose as the corresponding exact
projected-volume bound.

An exact subset-mask dynamic program computed

    Z_W = 66789669075252324604355198       (m=13),
    Z_W = 54013946937661977267573364860700421098   (m=19).

The 13-row Shearer bound first certifies 354 bits; the 19-row bound first
certifies 353 bits. Both are weaker than the retained 352-bit certificate.
The order-13 result was cross-checked by independent Python and C++ dynamic
programs; normal and optimized Python runs produced identical JSON (SHA-256
010667fbfe330084a06727bb2ce0054527d3c4cabbce0f370b64ac17a2f735e0).
The full weighted matching sum Z and the exact 120D zonotope volume were not
computed. This local Shearer relaxation therefore does not close the gap.

Reproduce with `python3 verify_matching_shearer.py` and
`python3 -O verify_matching_shearer.py`; the C++17 helper is
`matching_partition_dp.cpp`, and the exact record is
`matching_shearer_results.json`.

12. EXACT DEGREE-SIX COEFFICIENT FOR THE 20-COORDINATE COVER

The selected 20-set

    W={0,1,2,3,7,8,15,33,34,...,44,89}

was evaluated one degree further. Its 120 verified translates form a uniform
20-cover, and every one of the 120 projected columns of M is retained. The
exact projected-volume coefficients through degree six are

    [1, 500, 112874, 15362516, 1418124233, 94604206576,
     4741690567067].

The degree-six value is the complete sum of absolute 6-by-6 minors, with
generator multiplicities, not a sample or a permanent approximation. The
calculation covers 5,652,861,818 symmetry-expanded minor subsets. The
setwise stabilizer of W has order two, so 2,892,469,736 distinct minor cases
were evaluated. The matching permanent coefficients bound the remaining
degrees. This gives

    Vol_20(pi_W Z_M) <=
    4475573936847233352422870866423233712374.

The threshold comparison proves 352 bits and does not prove 351 bits. The
exact 20-dimensional projected volume and F_max remain uncomputed.

The degree-six exact coefficient can also be combined with the exact degree-
seven coefficient of the contained 13-neighborhood and permanent bounds for
the other degree-seven rowsets. For r=7, rowsets wholly inside the 13-set
contribute its exact a_7; all other rowsets are bounded by their permanent
sum. The resulting valid 20-dimensional projected-volume upper bound is

    4471408499009116423255293750903889587226.

This is sharper than the 20-cover's order-six permanent-tail bound, but still
fails the 351-bit threshold. Its per-coordinate bound is also weaker than the
retained 13-coordinate certificate. Thus this calculation validates and
refines the proposed overlapping-block route without lowering the paper's
best upper endpoint: the global interval remains 307 <= ell* <= 352 bits.

The order-five result was rerun in normal and optimized Python modes with
byte-identical JSON. The exact order-six sum used a C++17 OpenMP kernel with
nine threads and fraction-free Bareiss determinants; its coefficient and
threshold comparisons are integers. The nested coefficient/permanent checker
was run in both Python modes and produced byte-identical reports. Artifacts:
`verify_cover20_order5.py`, `cover20_order5.json`,
`verify_cover20_order6.py`, `zonotope_volume_parallel.cpp`,
`cover20_order6.json`, `verify_cover20_nested_bound.py`, and
`cover20_nested_bound.json`.

No order-seven sum for W was computed. No exact maximum fiber, exact C_10,
or optimal width was obtained by this extension.

PROVENANCE

The graph digest remains
40bc6a1d52efab3d75cf343e65ac06b314f9c9c375fc02bf6d45bf6bb21f9529.
The source baseline and proof remain preserved byte for byte in baseline/.
All newly computed zonotope coefficients use integer Bareiss determinants;
the permanent comparison and threshold tests use Python arbitrary-precision
integers. No floating-point calculation is used in a bound decision.
