From 69e70b1426c32b19da8334930815800a2c95ffca Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 04:57:31 -0500 Subject: [PATCH] Classify every irreducible seven-image pattern-five pool --- .../CREDITS.md | 38 + .../PROOF.md | 269 ++++++ .../README.md | 58 ++ .../RESULT.json | 773 ++++++++++++++++++ .../SOURCES.json | 18 + .../TASK.json | 79 ++ .../VERIFY.json | 34 + .../verify.py | 306 +++++++ 8 files changed, 1575 insertions(+) create mode 100644 research/no-edge-dim5-extremal-classification/CREDITS.md create mode 100644 research/no-edge-dim5-extremal-classification/PROOF.md create mode 100644 research/no-edge-dim5-extremal-classification/README.md create mode 100644 research/no-edge-dim5-extremal-classification/RESULT.json create mode 100644 research/no-edge-dim5-extremal-classification/SOURCES.json create mode 100644 research/no-edge-dim5-extremal-classification/TASK.json create mode 100644 research/no-edge-dim5-extremal-classification/VERIFY.json create mode 100644 research/no-edge-dim5-extremal-classification/verify.py diff --git a/research/no-edge-dim5-extremal-classification/CREDITS.md b/research/no-edge-dim5-extremal-classification/CREDITS.md new file mode 100644 index 0000000000..7bb23072b6 --- /dev/null +++ b/research/no-edge-dim5-extremal-classification/CREDITS.md @@ -0,0 +1,38 @@ +# Credit and source boundary + +Ali Romman prepared this package with substantial OpenAI Codex assistance. +New work is Apache-2.0. Independent human and formal-kernel review are +unclaimed. There is no external runtime package dependency. + +The structural reduction uses Ali Romman's disjoint-circuit theorem in +[PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md). +The small binary matrix, span, lift and orbit routines are reused from its +[exact verifier](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/verify.py). +That source retains credit to CubeJerry for the earlier intersecting-support +method and to Nick Petalas for the binary fiber lemma. + +unpaidmoon supplied the three-coordinate normal-form lemma in +[PR #6921](https://github.com/CrocSwap/integer-mult-bounds/pull/6921), +[exact proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/6020400853abc110134804fad04b695adc360bcd/research/no-edge-irreducible-image/PROOF.md), +and the two-block construction and open classification question in +[PR #7237](https://github.com/CrocSwap/integer-mult-bounds/pull/7237) and +[PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281), +[exact source](https://github.com/unpaidmoon/integer-mult-bounds/blob/0cd5324c41490b856d0e94daa8b011683fc153f6/research/no-edge-dim5-fresh-link/PROOF.md). + +Nick Petalas supplied the nonsymmetric link in +[PR #7648](https://github.com/CrocSwap/integer-mult-bounds/pull/7648), +[exact source](https://github.com/petalas/integer-mult-bounds/blob/f967555200c111925d48a46b65b124432a762b65/research/no-edge-asymmetric-block-link/README.md). +Ali Romman supplied the fixed-block fresh-factor classification in +[PR #7676](https://github.com/CrocSwap/integer-mult-bounds/pull/7676), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/943c355c233649f77f018e6247e5456584ef715e/research/two-block-fresh-link-classification/PROOF.md). +Its complete-pool proof is restated here with credit. + +The irreducible-image-basis classification in +[PR #7686](https://github.com/CrocSwap/integer-mult-bounds/pull/7686) and the +general extraction counterexample in +[PR #7688](https://github.com/CrocSwap/integer-mult-bounds/pull/7688) mark the +scope that this result extends. The new contribution excludes the other +complete-pool geometries and the zero fresh-covector boundary. The existing +positive links, their fixed-coordinate counts and the normal-form lemma +are not new results here. diff --git a/research/no-edge-dim5-extremal-classification/PROOF.md b/research/no-edge-dim5-extremal-classification/PROOF.md new file mode 100644 index 0000000000..4a94d0774e --- /dev/null +++ b/research/no-edge-dim5-extremal-classification/PROOF.md @@ -0,0 +1,269 @@ +# All irreducible seven-image pools at pattern dimension five + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +## 1. Classification + +Work over F2 in a fixed coordinate space. Let H be a five-dimensional +off-diagonal pattern space that contains no matrix unit. Its complete pool +consists of all rank-one idempotents with nonzero pattern in H. Suppose +that its joint image V has dimension seven and the pool acts irreducibly +on V. + +**Theorem.** After a coordinate permutation, the complete pool consists of +two normal-form triples on coordinates 0..2 and 3..5, together with exactly +one link: + +```text +First block: image/covector pairs (6,5), (5,6), (7,7). +Second block: the same pairs shifted by three coordinates. +h = e_2 + e_5. +Link = (h+a)(h+b)^T, + a,b supported outside the two blocks, a dot b = 1. +``` + +The integers encode binary coordinate supports. Every such family has a +complete unit-free pattern space of dimension five and irreducible image +dimension seven. Thus the displayed form is necessary and sufficient at +every ambient width. In particular, **every attaining irreducible complete +pool has exactly seven projectors**. No larger pool supplies another +attaining geometry. + +All these actions on V are isomorphic: in a suitable basis they consist of +the first six coordinate projectors and the all-one seven-by-seven matrix. +The parameterization permits arbitrary fresh supports a,b with pairing one. +It is not a count of coordinate-permutation orbits or a unique orbit +representative. + +This answers question 2 of +[PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281), +[exact source](https://github.com/unpaidmoon/integer-mult-bounds/blob/0cd5324c41490b856d0e94daa8b011683fc153f6/research/no-edge-dim5-fresh-link/PROOF.md). +The two-block construction and its links are prior work. The new step +forces that geometry for an arbitrary complete pool, without assuming an +irreducible image-basis subcollection. + +## 2. Two possible image-basis structures + +Choose any seven pool projectors with independent images. The total-image +and disjoint-circuit theorem in +[PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md), +gives pattern rank at least `ceil(14/3)=5`. Thus these seven projectors span +H, and their space of diagonal relations has dimension two. Its two circuit +supports are disjoint, and each has at least three members. The possibilities +are a triple and a quad, or two triples and one member in no relation. + +For each relation group, let U_j be its image span and S_j the coordinate +support of its diagonal sum. The source theorem proves that the S_j are +disjoint, every group covector is supported on S_j, and the coordinate space +on S_j lies in U_j. Also + +```text +1 <= |S_j| <= dim U_j, +|S_j| = dim U_j modulo 2. +``` + +The U_j have zero intersection because the selected images are independent. +These statements concern the chosen basis. The remainder of the proof +checks every projector in the complete pool. + +## 3. A column-support invariant + +Suppose a pattern space has zero columns outside a coordinate set S. Let V +be the joint image of any collection of its rank-one idempotent lifts. +Then + +```text +K = {v in V : v is zero on S} +``` + +is invariant under the whole collection. To see this, a projector whose +covector is supported on S kills K. If its covector has an outside bit j, +the zero off-diagonal column j forces its image to be e_j. This image lies +in V and is zero on S, so the projector maps K into K again. + +If V contains the coordinate space on S and `0<|S|> (r * width + j)) & 1) << r for r in range(width)) + y = (pattern >> (i * width)) & ((1 << width) - 1) + result = [] + for xj, yi in itertools.product((0, 1), repeat=2): + xx, yy = x | (xj << j), y | (yi << i) + if parity(xx & yy) and off(outer(xx, yy, width), width) == pattern: + result.append((xx, yy)) + return result + + + +def pool(pattern_basis, width): + return sorted(pair for pattern in span(pattern_basis) if pattern + for pair in lifts(pattern, width)) + + + +def orbit_irreducible(pairs): + """Check all nonzero vectors for small fixtures by direct closure.""" + image_space = span(x for x, _ in pairs) + n = len(basis(image_space)) + for value in image_space[1:]: + vectors = basis([value]) + while True: + expanded = basis((*vectors, *(x for x, y in pairs + if any(parity(y & v) for v in vectors)))) + if len(expanded) == len(vectors): + break + vectors = expanded + if len(vectors) != n: + return False + return True + + + +def unit_free(values): + return all(x.bit_count() != 1 for x in span(values)) + + + +def normal_block(shift): + return [(x << shift, y << shift) for x, y in ((6, 5), (5, 6), (7, 7))] + + +def column_triple(anchor, a, b, c): + t, u = (1 << a) | (1 << c), (1 << b) | (1 << c) + return [((1 << anchor) | v, 1 << anchor) for v in (t, u, t ^ u)] + + +def raw_idempotents(width): + return [(x, y, off(outer(x, y, width), width)) + for x, y in itertools.product(range(1, 1 << width), repeat=2) + if parity(x & y)] + + +def invariant_column_kernel(pairs, active): + image_space = span(x for x, _ in pairs) + kernel = {v for v in image_space if not v & active} + require(1 < len(kernel) < len(image_space), 'proper nonzero coordinate kernel') + for vector in basis(sorted(kernel)): + for x, y in pairs: + require(not parity(y & vector) or x in kernel, 'complete-pool invariant kernel') + return list(basis(sorted(kernel))) + + +def census(name, old, width, active, raw, zero_fresh_covector=False): + old_ps = patterns(old, width) + old_h = span(old_ps) + old_v = set(span(x for x, _ in old)) + require(len(old_h) == 16 and len(old_v) == 64 and unit_free(old_ps), 'old six-image pool') + by_pattern = defaultdict(list) + for x, y, pattern in raw: + if pattern: + by_pattern[pattern].append((x, y)) + old_pool = sorted(p for pattern in old_h if pattern for p in by_pattern[pattern]) + require(old_pool == sorted(old), 'complete even pool') + require(all(not y & ~active for _, y in old_pool), 'even covectors use active columns') + counts = Counter() + spaces = {} + rejected = set() + for x, y, pattern in raw: + if x in old_v or not pattern: + continue + if zero_fresh_covector and y & ~active: + continue + counts['candidate_links'] += 1 + representative = min(pattern ^ h for h in old_h) + require(representative, 'new image cannot have old nonzero pattern') + if representative in rejected: + continue + if representative not in spaces: + odd = [representative ^ h for h in old_h] + if any(p.bit_count() == 1 for p in odd): + rejected.add(representative) + continue + spaces[representative] = (x, y) + counts['unit_free_candidate_links'] += 1 + counts['distinct_unit_free_spaces'] = len(spaces) + counts['distinct_rejected_spaces'] = len(rejected) + case_counts = Counter() + examples = {} + digest = hashlib.sha256() + max_pool = 0 + outside_mask = ((1 << width) - 1) ^ active + for representative, link in sorted(spaces.items()): + odd_patterns = [representative ^ h for h in old_h] + odd_pool = sorted(p for pattern in odd_patterns for p in by_pattern[pattern]) + complete = sorted(old_pool + odd_pool) + require(pool(old_ps + [representative], width) == complete, 'raw scan and four-trial pools agree') + require(len(basis(x for x, _ in complete)) == 7, 'complete image has dimension seven') + max_pool = max(max_pool, len(complete)) + outside_columns = [j for j in range(width) if (outside_mask >> j) & 1 + and any((representative >> (i * width + j)) & 1 for i in range(width))] + if not outside_columns: + case = 'zero_outside_columns' + witness = invariant_column_kernel(complete, active) + else: + limit = 2 if len(outside_columns) == 1 else 1 + case = 'one_outside_column' if limit == 2 else 'multiple_outside_columns' + require(len({x for x, _ in odd_pool}) <= limit, 'odd image alternatives') + restrictions = {y & outside_mask for _, y in odd_pool} + require(len(restrictions) <= limit, 'odd covector restrictions') + require(len(basis(y for _, y in complete)) <= active.bit_count() + limit, 'ambient covector rank bound') + image_space = span(x for x, _ in complete) + vector = next((v for v in image_space if v and all(not parity(y & v) for _, y in complete)), None) + require(vector is not None, 'nonzero full common kernel') + witness = [vector] + case_counts[case] += 1 + record = {'representative': representative, 'link': link, 'pool': complete, + 'outside_columns': outside_columns, 'invariant_basis': witness} + digest.update((json.dumps(record, sort_keys=True, separators=(',', ':')) + '\n').encode()) + examples.setdefault(case, record) + return {'name': name, 'width': width, 'active_columns': active, 'old_pairs': old, + 'raw_idempotents': len(raw), 'counts': dict(sorted(counts.items())), + 'proof_case_counts': dict(sorted(case_counts.items())), 'maximum_complete_pool_size': max_pool, + 'all_space_certificates_sha256': digest.hexdigest(), 'one_example_per_case': examples} + + +def triple_quad_fixtures(): + quads = [([(15 ^ (1 << i), 15 ^ (1 << i)) for i in range(4)], 4, 15), + ([(25, 1), (13, 1), (23, 2), (21, 3)], 5, 3)] + result = [] + for quad, width, active in quads: + for kind in ('normal', 'column'): + if kind == 'normal': + triple = normal_block(width) + full_width, full_active = width + 3, active | (7 << width) + else: + triple = column_triple(width, width + 1, width + 2, width + 3) + full_width, full_active = width + 4, active | (1 << width) + pairs = quad + triple + ps = patterns(pairs, full_width) + require(len(basis(x for x, _ in pairs)) == 7, 'triple-quad image basis') + require(len(basis(ps)) == 5 and unit_free(ps), 'triple-quad pattern space') + complete = pool(ps, full_width) + require(len(basis(x for x, _ in complete)) == 7, 'triple-quad full image') + if full_active.bit_count() < 7: + witness = invariant_column_kernel(complete, full_active) + else: + block = set(range(1 << width)) + require(all(not parity(y & v) or x in block for v in basis(sorted(block)) for x, y in complete), 'coordinate block invariant') + witness = list(basis(sorted(block))) + require(not orbit_irreducible(complete), 'triple-quad direct orbit control') + result.append({'quad_active_rank': active.bit_count(), 'triple_kind': kind, + 'width': full_width, 'active_columns': full_active, 'pool': complete, + 'invariant_basis': witness}) + return result + + +def normal_form_census(): + count = survivors = 0 + triples = set() + for images in itertools.permutations(range(1, 8), 3): + if len(basis(images)) != 3: + continue + count += 1 + covectors = [next(y for y in range(1, 8) + if all(parity(x & y) == (i == j) for j, x in enumerate(images))) + for i in range(3)] + pairs = tuple(zip(images, covectors)) + ps = patterns(pairs, 3) + if all(ps) and unit_free(ps): + survivors += 1 + require(sorted(x.bit_count() for x in images) == [2, 2, 3], 'normal-form weights') + require(pool(ps, 3) == sorted(pairs), 'normal triple complete pool') + triples.add(tuple(sorted(pairs))) + require(count == 168 and survivors == 18 and len(triples) == 3, 'normal-form complete census') + return {'ordered_bases': count, 'ordered_survivors': survivors, 'unordered_triples': sorted(triples)} + + +def compute(): + raw7, raw8 = raw_idempotents(7), raw_idempotents(8) + require(len(raw7) == 8128 and len(raw8) == 32640, 'complete raw domains') + mixed = normal_block(0) + column_triple(3, 4, 5, 6) + columns = column_triple(0, 1, 2, 3) + column_triple(4, 5, 6, 7) + normal = normal_block(0) + normal_block(3) + censuses = [census('normal_and_column', mixed, 7, 15, raw7), + census('two_columns', columns, 8, 17, raw8), + census('normal_zero_fresh_covector', normal, 7, 63, raw7, True)] + positive = [] + for fresh_width, a, b in ((1, 1, 1), (2, 1, 3), (2, 3, 1), (3, 3, 5), (3, 7, 7), (4, 9, 5)): + require(parity(a & b), 'positive fresh pairing') + link = (36 | (a << 6), 36 | (b << 6)) + pairs = normal + [link] + ps = patterns(pairs, 6 + fresh_width) + require(len(basis(ps)) == 5 and unit_free(ps), 'positive pattern space') + require(pool(ps, 6 + fresh_width) == sorted(pairs), 'positive complete pool') + require(orbit_irreducible(pairs), 'positive full orbit check') + positive.append({'width': 6 + fresh_width, 'a': a, 'b': b, 'link': link}) + extra = pool(patterns(normal + [(64, 69)], 7), 7) + require(len(extra) == 8 and (70, 5) in extra and (64, 69) in extra, 'extra-pool predecessor control') + require(invariant_column_kernel(extra, 63) == [64], 'extra-pool line invariant') + return {'statement': 'Every complete unit-free pattern-five pool with irreducible image seven is two disjoint normal triples plus one hub link with nonzero fresh factors of pairing one.', + 'normal_form': normal_form_census(), 'excluded_link_censuses': censuses, + 'triple_quad_controls': triple_quad_fixtures(), 'prior_positive_families': positive, + 'extra_pool_control': extra, + 'scope': 'All-width written classification; finite scans cover the stated canonical excluded geometries, not all coordinate embeddings.', + 'kappa_change': None} + + +def main(): + actual = json.loads(json.dumps(compute())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + require(actual == expected, 'receipt mismatch') + print('PASS_NO_EDGE_DIM5_EXTREMAL_CLASSIFICATION') + print(json.dumps({'raw_idempotents': 40768, + 'candidate_links': sum(x['counts']['candidate_links'] for x in actual['excluded_link_censuses']), + 'complete_spaces': sum(x['counts']['distinct_unit_free_spaces'] for x in actual['excluded_link_censuses'])}, sort_keys=True)) + + +if __name__ == '__main__': + main()