From 68c3c7dd16fe87d86386d7dc61ae566c552925cc Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Fri, 13 Nov 2026 14:21:11 +0000 Subject: [PATCH] feat(research): exclude the six-point rank-four sojourn --- research/rank4-six-point-sojourn/PROOF.md | 92 +++++++++++++ research/rank4-six-point-sojourn/README.md | 79 +++++++++++ research/rank4-six-point-sojourn/SOURCES.json | 24 ++++ research/rank4-six-point-sojourn/TASK.json | 83 ++++++++++++ research/rank4-six-point-sojourn/VERIFY.json | 34 +++++ research/rank4-six-point-sojourn/verify.py | 124 ++++++++++++++++++ 6 files changed, 436 insertions(+) create mode 100644 research/rank4-six-point-sojourn/PROOF.md create mode 100644 research/rank4-six-point-sojourn/README.md create mode 100644 research/rank4-six-point-sojourn/SOURCES.json create mode 100644 research/rank4-six-point-sojourn/TASK.json create mode 100644 research/rank4-six-point-sojourn/VERIFY.json create mode 100644 research/rank4-six-point-sojourn/verify.py diff --git a/research/rank4-six-point-sojourn/PROOF.md b/research/rank4-six-point-sojourn/PROOF.md new file mode 100644 index 0000000000..3423839972 --- /dev/null +++ b/research/rank4-six-point-sojourn/PROOF.md @@ -0,0 +1,92 @@ +# The six-point rank-four sojourn is impossible at length 30 + +This contribution was produced by Nick Petalas. Apache-2.0. + +Claim type: a scoped written proof with exact finite corroboration. + +## Three translates require half the binary group + +Let G be an elementary abelian binary group of order 2^r, r >= 2. +If A has three distinct elements and A+B=G, then |B| >= 2^(r-1). + +Translate A to {0,a,b}. The nonzero distinct vectors a,b are linearly +independent, so H={0,a,b,a+b} is a subgroup of order four. Addition by A +preserves each H-coset. A coset containing at most one point of B contributes +at most three points to A+B and cannot be covered. Every one of the 2^(r-2) +cosets must therefore contain at least two points of B. This proves the bound. + +The bound is sharp. In G=F_2^4, A={0,1,2} and +B={0,1,4,5,8,9,12,13} cover G. Numbers encode binary coordinate vectors. +The argument is elementary additive counting; no literature-wide priority +claim is made for the abstract lemma. + +## Apply the lemma separately in eight fibers + +Consider a closed singleton source word of length L on the eight coordinate +directions of F_2^8. Let P be its visited prefix set, including its initial +zero state and excluding the duplicate final state. Universality requires +P+P=F_2^8, using Ross Richardson's #943 prefix criterion. + +Fix a source alpha that occurs exactly twice. Its two occurrences split P +into alpha-bit-zero and alpha-bit-one layers. Delete coordinate alpha and +call the two resulting sets Q0,Q1. The sets may overlap after projection, +but projection is injective within each layer, so + + |Q0| + |Q1| = |P| <= L. + +Every difference with alpha-bit one uses one point from each layer. Thus +universality necessarily implies + + Q0 + Q1 = F_2^7. (1) + +This is the sojourn split of unpaidmoon #6943, retained by #7015 and #7093. +Its elementary derivation is included to keep this proof self-contained. + +Suppose the steps strictly between the alpha occurrences use exactly four +other coordinate directions. Their span is a four-dimensional space V, +and Q1 lies in an affine V-coset. Translate that layer to arrange Q1 subset V; +this only translates the left side of (1), preserving the covering property. +Choose a complementary three-dimensional space W, so F_2^7=V direct-sum W. +For each w in W write + + F_w = {v in V : v+w belongs to Q0}. + +Equation (1) implies F_w+Q1=V for every w. Now impose the separate case +left open in #7093, namely |Q1|=6. + +If |F_w| <= 2, then |F_w+Q1| <= 12 < 16. If |F_w|=3, the lemma would require +|Q1| >= 8. Both are impossible. Hence every fiber has at least four points, +and there are eight fibers. Consequently + + |Q0| >= 32, + L >= |Q0|+|Q1| >= 38. (2) + +In particular no universal closed length-30 word has this six-point +rank-four sojourn. This excludes the proposed (|Q0|,|Q1|)=(24,6) boundary. +Repeated prefixes cannot evade (2); they only decrease |P| relative to L. + +The cross-layer lower bound |Q0|>=32 is sharp as a set-cover statement. +Take Q1={0,1,2,3,4,8} in V, K={0,4,8,12}, and Q0=K direct-sum W. +The first four points of Q1 form a complement of K in V, so Q0+Q1=F_2^7. +These sets have sizes 32 and 6. Their same-layer sums do not cover F_2^7. +They are not asserted to be a universal prefix set or a length-38 word. + +## Exact scope and predecessor credit + +The new result closes the explicitly unsearched size-six case of unpaidmoon +#7093 at 94b36d4649b5d29829959409acbc1906ef0b4379. Its sixteen-point census, +#7015's rank-three obstruction, #6943's bent census, and the length-28 +results are cited, not replayed or validated by this package. No one else's +reported numerical census is needed for (2). In particular (2) does not +require f(7)=24 or a multiplicity classification of the full word. + +The first working example is the six-point Q1 and three-point F={0,1,2}. +The finite checker exhausts every six-point Q1 and every three-point F in V. +Its separate literal-set implementation normalizes F and exhausts Q1 again. +Affine invariance relates the two computations. The all-size statement +rests on the written counting proof, not on the finite checker alone. + +Other layer sizes and ranks remain open here. This is no new bound on f(8), +native construction, physical tariff, kappa improvement, or complete +multiplication theorem. No proof assistant or independent human acceptance +is claimed. diff --git a/research/rank4-six-point-sojourn/README.md b/research/rank4-six-point-sojourn/README.md new file mode 100644 index 0000000000..af5537fcd6 --- /dev/null +++ b/research/rank4-six-point-sojourn/README.md @@ -0,0 +1,79 @@ +# Exclude the six-point rank-four sojourn at length 30 + +This contribution was produced by Nick Petalas. Apache-2.0. + +Claim type: scoped written proof with exact finite corroboration. + +A universal closed eight-source binary singleton word of length 30 cannot +have a multiplicity-two source whose rank-four sojourn visits exactly six +distinct projected states. Such a layer requires at least 32 complementary +states and therefore at least 38 prefix slots. This closes the separate +size-six case explicitly left open in unpaidmoon's +[PR #7093](https://github.com/CrocSwap/integer-mult-bounds/pull/7093), head +`94b36d4649b5d29829959409acbc1906ef0b4379`. + +The new step is an affine-plane coset argument applied in each quotient +fiber. Three translates can cover an elementary binary group only when the +other set has at least half the group. Six points in F_2^4 therefore need +at least four translating points per fiber. Eight fibers require 32 points. +[PROOF.md](PROOF.md) gives the self-contained argument and an attaining +cross-layer set cover. That cover is not a universal word. + +## Evidence and reproduction + +CPython 3.12, standard library only, from the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -I -B research/rank4-six-point-sojourn/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -I -O -B research/rank4-six-point-sojourn/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/rank4-six-point-sojourn +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/rank4-six-point-sojourn --check-source-history +``` + +The verifier enumerates all 8,008 six-sets and 560 triples in F_2^4, +checking 4,484,480 sumsets. A separate literal-set check covers all 8,008 +six-sets against a normalized triple. The full and normalized cardinality +histograms must agree under affine symmetry. Explicit fixtures check the +32+6 sharp cross-layer cover, its failed same-layer condition, and four +boundary controls. The generated JSON receipt includes every package-file +SHA256 and the marker `PASS_RANK4_SIX_POINT_SOJOURN`. No receipt is committed +or hand-authored. No predecessor executable is imported or replayed. + +The code has fixed finite domains, no recursion, no subprocesses and no +runtime file writes. Python allocates managed objects during enumeration; +the largest retained census collection has 560 triples, and all individual +sumsets have at most 128 elements. Functions stay below 60 lines. Explicit +exceptions keep proof checks active under optimization. The registered +warning-strict normal and optimized commands provide the local diagnostics. + +## Scope, sources and credit + +The connector-alphabet-change card is explicitly changed to this algebraic +side result within the existing alphabet. It removes one live candidate +boundary; it supplies no changed operation or complete supplier bill. +The card's old 945-pairing replay is outside this new question. The working +example here is the six-point layer and its three-point translation test. + +Credit unpaidmoon #7093 for the separate size-six question and its rank-four +setting, #7015 and #6943 for the sojourn split and preceding exclusions; +Ross Richardson #943 for the singleton model and prefix criterion; Douglas +Colkitt #1185, conorholds #3058, Nick Petalas #5234, and Nicholas Stone #5430 +for the retained eight-source lineage. Their bounds and constructions are +cited rather than reverified. This proof neither uses nor extends #7321's +adjacent-pair degree argument. Main sources are pinned in SOURCES.json; +the pending question source is identified by URL and exact head in TASK.json +and this document, with no runtime dependence on its unmerged Git objects. + +The selected record remains unchanged. No new f(8) bound, physical schedule, +native/stock/precision/caller admission or multiplication theorem is claimed. +No Lean, Docker, selected cold replay or proof-kernel check was run. +Independent human and formal proof-kernel review are unclaimed. + +## Open next questions + +Does a universal length-30 word survive the remaining rank-four sizes and +the higher-rank cases? First search one rank-four layer with 17 complementary +points, using #7093's existing constraints and excluding size six by this +proof. This matters because a word would lower the length-32 upper bound. +The coupled same-layer cover and legal chronological walk remain blockers. +No further search or tighter boundary is part of this contribution. diff --git a/research/rank4-six-point-sojourn/SOURCES.json b/research/rank4-six-point-sojourn/SOURCES.json new file mode 100644 index 0000000000..431eb03286 --- /dev/null +++ b/research/rank4-six-point-sojourn/SOURCES.json @@ -0,0 +1,24 @@ +{ + "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/length30-singleton-sojourn/README.md", + "usage": "provenance", + "git_blob": "77a202d43846913a61aa670eef2dbe122387f500", + "sha256": "a2f58cecb00df69d3f7edca9e30516da91107d8c22eb447bd9c15591f67fd8d3" + } + ] +} diff --git a/research/rank4-six-point-sojourn/TASK.json b/research/rank4-six-point-sojourn/TASK.json new file mode 100644 index 0000000000..fc828b6e71 --- /dev/null +++ b/research/rank4-six-point-sojourn/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "connector-alphabet-change", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment.", + "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + }, + "scope_status": "changed", + "actual_scope": "Exclude the six-point layer in a rank-four multiplicity-two sojourn of a universal closed length-30 eight-source singleton word.", + "scope_change_reason": "The question is the separate size-six boundary left open in unpaidmoon PR7093, rather than a new connector operation. A new affine-plane coset argument excludes this boundary without replaying predecessor results.", + "bottleneck_link": "Algebraic side result: removes one live singleton connector candidate boundary. A shorter universal word could reduce a connector query bill; no complete supplier or kappa improvement is claimed.", + "budget_minutes": 60, + "stop_rule": "Stop at the first verified exclusion of the size-six rank-four boundary and package it; do not extend the word search.", + "outcome": "completed", + "evidence": "PROOF.md and verify.py: self-contained counting proof, complete 4,484,480 sumset census, independent 8,008-case normalized census, sharp cross-layer fixture and four boundary controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Does a universal length-30 word survive the remaining rank-four and higher-rank cases?", + "why_it_matters": "A word would lower the length-32 singleton upper bound; this package only removes the size-six rank-four boundary.", + "first_step": "Search a rank-four sojourn with 17 complementary points using PR7093 constraints, with size six excluded by this proof.", + "blocked_by": "The same-layer difference cover and a legal closed chronological walk must both hold; no such word is supplied." + } + ], + "question_source": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7093", + "head": "94b36d4649b5d29829959409acbc1906ef0b4379", + "author": "unpaidmoon", + "scope": "Explicitly separate six-point rank-four layer in Open next questions. Documentary citation only, no unmerged runtime dependency." + }, + "claim_type": "scoped written proof with exact finite corroboration", + "overlap": { + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19592097", + "read_prs": [ + 6943, + 6966, + 7015, + 7088, + 7093, + 7321 + ], + "coverage": "Live open PR list, own recent PR bodies, latest handoff comments, active discussion bodies, targeted all-state and merged searches, and origin/main README searches. find_overlap offline inventory is sparse and has no remote snapshot. No match is a novelty certificate.", + "source_reuse": "PR7093 supplies no other target among this account recent PR bodies or active local locks when reserved. Its author and direct predecessor author are unpaidmoon. The proof does not use this account older packages as its main step." + } +} diff --git a/research/rank4-six-point-sojourn/VERIFY.json b/research/rank4-six-point-sojourn/VERIFY.json new file mode 100644 index 0000000000..bd3b5adf10 --- /dev/null +++ b/research/rank4-six-point-sojourn/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete six-set/triple sumset census; independent normalized literal-set census; cross-layer attaining fixture and same-layer failure; four boundary controls; generated package-hash receipt." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Repeat all checks with optimization; explicit exceptions remain enabled." + } + ] +} diff --git a/research/rank4-six-point-sojourn/verify.py b/research/rank4-six-point-sojourn/verify.py new file mode 100644 index 0000000000..67df755828 --- /dev/null +++ b/research/rank4-six-point-sojourn/verify.py @@ -0,0 +1,124 @@ +"""Exact finite corroboration of the six-point sojourn exclusion. + +Produced by Nick Petalas. Apache-2.0. +No predecessor executable, Git object, network or optional dependency is used. +""" + +import hashlib +import itertools +import json +from pathlib import Path +import platform + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def sumset(left, right): + return {x ^ y for x in left for y in right} + + +def translated_masks(points): + return tuple(sum(1 << (x ^ shift) for x in points) for shift in range(16)) + + +def complete_census(): + """Every six-set and every three-set in the four-dimensional group.""" + triples = tuple(itertools.combinations(range(16), 3)) + histogram = [0] * 17 + six_sets = 0 + for six in itertools.combinations(range(16), 6): + shifts = translated_masks(six) + for a, b, c in triples: + cardinality = (shifts[a] | shifts[b] | shifts[c]).bit_count() + require(cardinality < 16, "three translates covered the group") + histogram[cardinality] += 1 + six_sets += 1 + require(six_sets == 8008, "incomplete six-set domain") + require(len(triples) == 560, "incomplete triple domain") + require(sum(histogram) == 4484480, "incomplete paired domain") + return six_sets, len(triples), histogram + + +def independent_normalized_census(): + """Literal sets, independently of the bit-mask union implementation.""" + histogram = [0] * 17 + for six in itertools.combinations(range(16), 6): + union = sumset((0, 1, 2), six) + require(len(union) < 16, "normalized triple covered the group") + # The three-point set spans H={0,1,2,3}; inspect its four cosets. + for representative in (0, 4, 8, 12): + coset = {representative ^ h for h in range(4)} + if len(set(six) & coset) <= 1: + require(len(union & coset) <= 3, "coset argument failed") + histogram[len(union)] += 1 + require(sum(histogram) == 8008, "incomplete normalized domain") + return histogram + + +def fiber_fixture(): + six = (0, 1, 2, 3, 4, 8) + four = (0, 4, 8, 12) + require(sumset(four, six) == set(range(16)), "sharp fiber fixture failed") + q0 = {v | (w << 4) for v in four for w in range(8)} + q1 = set(six) + require(len(q0) == 32 and len(q1) == 6, "bad layer cardinalities") + require(sumset(q0, q1) == set(range(128)), "cross-layer fixture failed") + # Cross-layer sharpness alone must not be called a universal prefix set. + require(sumset(q0, q0) | sumset(q1, q1) != set(range(128)), + "fixture unexpectedly satisfies the same-layer condition") + return q0, q1 + + +def boundary_controls(q0, q1): + # Four translates can cover with six points, so 'three' is essential. + require(len(sumset((0, 4, 8, 12), q1)) == 16, + "four-translate counterexample lost") + # In an odd cyclic group the affine-plane argument does not apply. + cyclic = {(a + b) % 5 for a in (0, 1, 2) for b in (0, 3)} + require(cyclic == set(range(5)), "odd-group counterexample lost") + # Half the group is a sharp threshold for the three-translate lemma. + half = (0, 1, 4, 5, 8, 9, 12, 13) + require(sumset((0, 1, 2), half) == set(range(16)), + "half-group boundary fixture lost") + # Omitting an entire quotient fiber destroys the cross-layer cover. + omitted = {x for x in q0 if x >> 4 != 7} + require(len(omitted) == 28 and len(sumset(omitted, q1)) == 112, + "missing-fiber control failed") + return 4 + + +def main(): + six_sets, triples, histogram = complete_census() + independent = independent_normalized_census() + require(histogram == [560 * count for count in independent], + "affine-normalized and full censuses disagree") + q0, q1 = fiber_fixture() + controls = boundary_controls(q0, q1) + require(len(q0) + len(q1) == 38, "sharp cross-layer total changed") + package = Path(__file__).resolve().parent + files = ("README.md", "PROOF.md", "TASK.json", "SOURCES.json", + "VERIFY.json", "verify.py") + receipt = { + "status": "PASS_RANK4_SIX_POINT_SOJOURN", + "claim_type": "scoped proof with exact finite corroboration", + "six_sets": six_sets, + "triples": triples, + "paired_sumsets": sum(histogram), + "full_histogram": histogram, + "normalized_histogram": independent, + "complementary_layer_floor": 32, + "cross_layer_total_floor": 38, + "sharp_cross_layer_sizes": [len(q0), len(q1)], + "boundary_controls": controls, + "python": platform.python_version(), + "sha256": {name: hashlib.sha256((package / name).read_bytes()).hexdigest() + for name in files}, + } + print(json.dumps(receipt, sort_keys=True)) + + +if __name__ == "__main__": + main()