From 66711b58077a660341359e9baacedc304adc791f Mon Sep 17 00:00:00 2001 From: Aaron Wang <50366676+navinor@users.noreply.github.com> Date: Wed, 14 Oct 2026 01:12:35 -0400 Subject: [PATCH] test(research): certify an E8 incidence boundary --- .../CERTIFICATE.json | 399 ++++++++++++++++++ .../README.md | 160 +++++++ .../SOURCES.json | 30 ++ .../TASK.json | 83 ++++ .../VERIFY.json | 28 ++ .../test_verify.py | 46 ++ .../verify.py | 201 +++++++++ 7 files changed, 947 insertions(+) create mode 100644 research/e8-connectivity-incidence-boundary/CERTIFICATE.json create mode 100644 research/e8-connectivity-incidence-boundary/README.md create mode 100644 research/e8-connectivity-incidence-boundary/SOURCES.json create mode 100644 research/e8-connectivity-incidence-boundary/TASK.json create mode 100644 research/e8-connectivity-incidence-boundary/VERIFY.json create mode 100644 research/e8-connectivity-incidence-boundary/test_verify.py create mode 100644 research/e8-connectivity-incidence-boundary/verify.py diff --git a/research/e8-connectivity-incidence-boundary/CERTIFICATE.json b/research/e8-connectivity-incidence-boundary/CERTIFICATE.json new file mode 100644 index 0000000000..82254ad0ea --- /dev/null +++ b/research/e8-connectivity-incidence-boundary/CERTIFICATE.json @@ -0,0 +1,399 @@ +{ + "schema_version": 1, + "frame0": [ + 0, + 1, + 6, + 11, + 20, + 29, + 106, + 119 + ], + "pivot": [ + 2, + 5, + 8, + 9, + 30, + 41, + 108, + 117 + ], + "deleted_lines": [ + 32, + 45, + 73, + 78, + 88 + ], + "coordinate": 2, + "negative_lines": [ + 7, + 23, + 26, + 33, + 34, + 38, + 44, + 47, + 52, + 60, + 68, + 71, + 72, + 76, + 83, + 87, + 91, + 92, + 95, + 96, + 100, + 103, + 111 + ], + "result": { + "root_order_sha256": "499909f15616b21ed34b704054685a0c90c244fb81819ba458e076b8dd97308c", + "all_frames": 2025, + "live_frames": 877, + "selected_frames": 347, + "selected_frames_sha256": "bebba89e17f6b1746cac32e714201156b3bf1cb0941e22249465200e92693ba1", + "graphs": [ + { + "pair": [ + 2, + 5 + ], + "vertices": 20, + "edges": 60, + "edges_sha256": "35136750b5264291585a41080eb7c451b98de0b97eb0cf5694c8d1701fc7cec4" + }, + { + "pair": [ + 2, + 8 + ], + "vertices": 20, + "edges": 69, + "edges_sha256": "ffa76fb454dcce14f08aefba61bb368667b6a1249c3bda2fc1c06a575c8869e8" + }, + { + "pair": [ + 2, + 9 + ], + "vertices": 19, + "edges": 61, + "edges_sha256": "ecee5fef2b35ca049b0aa6fdd2356fb2391746de0bdc61b56c0e2fc5e0b75cc0" + }, + { + "pair": [ + 2, + 30 + ], + "vertices": 23, + "edges": 82, + "edges_sha256": "3477ca23289123c1a34497445c8a7b6cbe13e2ecfc5a2284d6cdde9ef2ad470e" + }, + { + "pair": [ + 2, + 41 + ], + "vertices": 24, + "edges": 84, + "edges_sha256": "3a4249905cfcb7225c2af320077f2b9e94dfc5bee538170f575f9562e824a35d" + }, + { + "pair": [ + 2, + 108 + ], + "vertices": 24, + "edges": 89, + "edges_sha256": "1593b5ad0b14ad28447a746db007cee84febaa7e25fd6292bed947e0540c83c9" + }, + { + "pair": [ + 2, + 117 + ], + "vertices": 23, + "edges": 86, + "edges_sha256": "a8e783cbedd8cec7216f9d458b9607435df256b39cbf4d281507f2cf81960839" + }, + { + "pair": [ + 5, + 8 + ], + "vertices": 18, + "edges": 64, + "edges_sha256": "b6bbcdf4553e5ef34469af6d9f9c148953b8c262aa242d9338a3c7aa0a600415" + }, + { + "pair": [ + 5, + 9 + ], + "vertices": 19, + "edges": 71, + "edges_sha256": "415a1cc741c80f4dafbbd4e84797cadc47038f6a5a03638040aa16a6cd587ec4" + }, + { + "pair": [ + 5, + 30 + ], + "vertices": 22, + "edges": 90, + "edges_sha256": "c38f7f642cee7326ee0a9b172fb5396fdfdeeb7501578ca9cb66a5e08ad8111f" + }, + { + "pair": [ + 5, + 41 + ], + "vertices": 23, + "edges": 95, + "edges_sha256": "0c65b131a18996b4cdc5e8c0fa59368c8fba46e815e68f7f0d1adc797a172105" + }, + { + "pair": [ + 5, + 108 + ], + "vertices": 22, + "edges": 96, + "edges_sha256": "b890ffe46f031fb82d2d8846c5113dfccc3de146487bd11ec8c00ba717f460bc" + }, + { + "pair": [ + 5, + 117 + ], + "vertices": 23, + "edges": 102, + "edges_sha256": "29e18e03a1b6077f16944755eef9b1f463b716be521a5f9ef685074d78148fea" + }, + { + "pair": [ + 8, + 9 + ], + "vertices": 19, + "edges": 67, + "edges_sha256": "4c9091eaabf1348fc2f3d5ed28e20c8092a7852e68aed963286069cb888a393b" + }, + { + "pair": [ + 8, + 30 + ], + "vertices": 22, + "edges": 97, + "edges_sha256": "09e7c0d3b8a4c916a239bd8a9c902929969c65b233205c69d1161a70bf2d05f1" + }, + { + "pair": [ + 8, + 41 + ], + "vertices": 22, + "edges": 97, + "edges_sha256": "fe8c2d934e5c3293c1d93af4eab00465de277c86357fd094b376bb25c3b189d2" + }, + { + "pair": [ + 8, + 108 + ], + "vertices": 23, + "edges": 102, + "edges_sha256": "d8f387724b8a012ff7979e0c5c5fa543a13887b9853507ac0b77fdb6747ab510" + }, + { + "pair": [ + 8, + 117 + ], + "vertices": 23, + "edges": 103, + "edges_sha256": "89b7a08c127833934726de705a67fdbc3bfdb9cc6bda0eadaaab143f3bd2ca39" + }, + { + "pair": [ + 9, + 30 + ], + "vertices": 21, + "edges": 89, + "edges_sha256": "e6fcb98ed056da07fee528291e23f99681cd21d96afd9e8ded8996a99c6b4b21" + }, + { + "pair": [ + 9, + 41 + ], + "vertices": 23, + "edges": 95, + "edges_sha256": "a8cde9bea7dfe4b23ae20bf6750cfea56e332e9f46e6df22482a9c8eb71e0bd1" + }, + { + "pair": [ + 9, + 108 + ], + "vertices": 23, + "edges": 96, + "edges_sha256": "56f7b00ccdfa71b7b15d3b83db64bd2a057293326c0c283a9b8e6cc953a513f3" + }, + { + "pair": [ + 9, + 117 + ], + "vertices": 23, + "edges": 103, + "edges_sha256": "9cac13ebd0bd2a23631751db3a5b9cfb294140ec46c97d4ae7f45b909cc2fdfb" + }, + { + "pair": [ + 30, + 41 + ], + "vertices": 19, + "edges": 69, + "edges_sha256": "3bb7272ce478b3965dedc9223981f35c430e2f47264b20ef774ab0a7d9454f7b" + }, + { + "pair": [ + 30, + 108 + ], + "vertices": 19, + "edges": 71, + "edges_sha256": "6d5d558f5ec37cde25db82fca0bdb76ff082efac1e95844411082ce1b6980f01" + }, + { + "pair": [ + 30, + 117 + ], + "vertices": 18, + "edges": 66, + "edges_sha256": "7db84ceffa7640d9f03edb20b55310666f216d46440d319ff4bd193328357bff" + }, + { + "pair": [ + 41, + 108 + ], + "vertices": 19, + "edges": 72, + "edges_sha256": "45fb4ab0db8145b3f32652c326cd13b120059e6753bf7b22fbe80beb8ca80f46" + }, + { + "pair": [ + 41, + 117 + ], + "vertices": 20, + "edges": 80, + "edges_sha256": "8285a16570a9619740f3fe86d2207c2a5af76c5fa7eea55e1edafebf9ce74b0f" + }, + { + "pair": [ + 108, + 117 + ], + "vertices": 20, + "edges": 79, + "edges_sha256": "9487393eca0b28e5205fa1092a8dbf9ac2d3166af076493d9e34a59e163f25f1" + } + ], + "ranks": [ + { + "coordinate": 2, + "columns": 51, + "selected_rank": 43, + "full_rank": 44, + "required_D_rank": 44 + }, + { + "coordinate": 5, + "columns": 49, + "selected_rank": 42, + "full_rank": 42, + "required_D_rank": 42 + }, + { + "coordinate": 8, + "columns": 49, + "selected_rank": 42, + "full_rank": 42, + "required_D_rank": 42 + }, + { + "coordinate": 9, + "columns": 49, + "selected_rank": 42, + "full_rank": 42, + "required_D_rank": 42 + }, + { + "coordinate": 30, + "columns": 48, + "selected_rank": 41, + "full_rank": 41, + "required_D_rank": 41 + }, + { + "coordinate": 41, + "columns": 50, + "selected_rank": 43, + "full_rank": 43, + "required_D_rank": 43 + }, + { + "coordinate": 108, + "columns": 50, + "selected_rank": 43, + "full_rank": 43, + "required_D_rank": 43 + }, + { + "coordinate": 117, + "columns": 50, + "selected_rank": 43, + "full_rank": 43, + "required_D_rank": 43 + } + ], + "full_family_q_obstruction": { + "frame": [ + 3, + 4, + 7, + 10, + 30, + 41, + 108, + 117 + ], + "sum": 2 + }, + "one_frame_repair_ranks": [ + 44, + 42, + 42, + 42, + 41, + 43, + 43, + 43 + ], + "scope": "selected subfamily only; all-live-frame implication remains open" + } +} diff --git a/research/e8-connectivity-incidence-boundary/README.md b/research/e8-connectivity-incidence-boundary/README.md new file mode 100644 index 0000000000..15b1b238c0 --- /dev/null +++ b/research/e8-connectivity-incidence-boundary/README.md @@ -0,0 +1,160 @@ +# Connected frame subfamilies need not saturate diagonal incidence + +**Exact finite counterexample to (G) ⇒ (D) for selected genuine E8 frame +subfamilies. No decoder, supplier, cost-floor or new κ claim.** + +The [handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18914508) +asks whether two-point connectivity can replace eight diagonal-incidence rank +computations. The criterion in +https://github.com/CrocSwap/integer-mult-bounds/pull/1560 allows a chosen finite +family of live frames. Its application in +https://github.com/CrocSwap/integer-mult-bounds/pull/1616 uses **all** live frames. +These scopes must be distinguished: the general chosen-family implication is +false; the all-live-family implication remains open here. + +## Explicit object and result + +Generate the doubled E8 roots of squared length eight: vectors with two entries +±2 and the rest zero, or eight entries ±1 with an even number of negatives. +Choose the representative whose first nonzero entry is positive and sort +lexicographically, obtaining 120 root-line IDs. Set `G_ij = v_i·v_j/4`. +A frame is eight mutually orthogonal lines. + +```text +FRAME0 = (0,1,6,11,20,29,106,119) +X = (32,45,73,78,88) +F = (2,5,8,9,30,41,108,117) +L = {0,...,119} minus FRAME0 minus X (107 live lines) +``` + +There are 2,025 frames in the full geometry and 877 wholly inside L. For each +pivot coordinate k in F, put +`I_k = {i in L minus F : G_ik != 0}`. Define q on the 51 entries of I₂ to be −1 +on the following lines and +1 on the others: + +```text +7,23,26,33,34,38,44,47,52,60,68,71,72,76,83,87,91,92,95,96,100,103,111 +``` + +Select **every** live frame S for which `Σ_{i in S∩I₂} q_i = 0`. This defines +a family of 347 genuine frames, including F, without any RNG dependency in the +certificate. The bounded proposal search found it on its first vector. + +For every unordered pivot pair k,ℓ, form the graph on `I_k∩I_ℓ`, with an edge +between i,j exactly when a selected frame intersects that vertex set in {i,j}. +**All 28 nonempty graphs are connected**, satisfying (G). + +Let M[I_k] be the selected-frame incidence matrix. The seven vectors +`h_kℓ(i)=G_ik G_iℓ`, ℓ≠k, are independent and satisfy `M h_kℓ=0` exactly. +At k=2 the additional vector q lies in the kernel and is independent of all +seven. The ranks are: + +| k | columns | selected rank | required (D) rank / full-family rank | +|---|---:|---:|---:| +| 2 | 51 | **43** | **44** | +| 5 | 49 | 42 | 42 | +| 8 | 49 | 42 | 42 | +| 9 | 49 | 42 | 42 | +| 30 | 48 | 41 | 41 | +| 41 | 50 | 43 | 43 | +| 108 | 50 | 43 | 43 | +| 117 | 50 | 43 | 43 | + +## Why this is an exact counterexample + +The direct integer kernel products give rational-rank upper bounds. Gaussian +elimination modulo the verified prime 1,000,003 gives lower bounds: a nonzero +minor modulo a prime is a nonzero integer minor. The bounds meet for every +reported rank. Modular rank is **not** treated as a stand-alone upper bound. +The augmented kernel matrix has modular rank eight, so q cannot be in the +seven-vector rational span. Thus `rank_Q M[I₂] = 43 < 51−7`, violating (D) +while (G) holds. The same bounds hold over any characteristic-zero field. + +Selecting rows that annihilate a chosen extra vector is the mechanism; merely +sampling an unconditioned frame family need not expose it. This does not +construct nongauge factors or refute the predecessor's theorem, which assumes +(D) separately. Nonlinear projector equations could impose more constraints +than this incidence system; no claim about their solution set is made. + +The complete 877-frame family satisfies all eight (D) identities. The omitted +frame `(3,4,7,10,30,41,108,117)` has q-sum **2**. Adding just this frame to the +347-family restores **all eight** required ranks. Zero added frames cannot +repair its deficit; this single-frame repair is attained, not a universal +repair theorem. Connectivity survives because adding edges cannot disconnect +the unchanged vertex sets. The certificate records this control explicitly. + +## Reproduce + +Python 3.10+, standard library only, from the repository root: + +```sh +python3 -I -O -B research/e8-connectivity-incidence-boundary/verify.py +python3 -I -O -B research/e8-connectivity-incidence-boundary/test_verify.py +python3 scripts/research_package.py --package research/e8-connectivity-incidence-boundary --check-only +python3.12 scripts/research_package.py --package research/e8-connectivity-incidence-boundary +``` + +Expected verifier output: + +```text +PASS_E8_CONNECTIVITY_INCIDENCE_BOUNDARY live=877 selected=347 graphs=28 rank=43 required=44 canonical_kernel=7 extra_kernel=1 full_family_control=PASS one_frame_repair=PASS +``` + +The checker independently regenerates roots, frames, graph edges, all kernel +identities and all reported ranks, then compares its deterministic receipt with +[CERTIFICATE.json](CERTIFICATE.json). It imports no predecessor checker and uses +no floating point. `--write` explicitly regenerates the result after the +mathematical checks. Replays otherwise do not change evidence files. +Two unittest groups exercise a positive optimized CLI and five rejection +controls: deleted pivot, invalid negative support, disconnected signs, false +rank and an omitted graph receipt. A pivot-only graph is also rejected inside +the verifier. Local replay takes about two seconds including these controls. + +## Task, budget and provenance + +Base `858771bcca3b8dd5d4ef4aa682a13cc9b7e23920`; complex-mechanisms assignment; +OS nonce `0d6468a107c6f96e18bdef01e3e8f622`; original card +`complex-rank-shape-decoder`, scope key `02b31ebd160542c86299`. +[TASK.json](TASK.json) records the **changed** scope, exact object and stop rule. +This is a prerequisite-verification side result and does not meet the card's +physical construction acceptance gate. No replacement invoice or a 0) + require(len(roots) == len(set(roots)) == 120, 'root count') + dots = [[sum(x*y for x, y in zip(a, b)) for b in roots] for a in roots] + require(all(t % 4 == 0 for row in dots for t in row), 'Gram integrality') + return roots, [[t//4 for t in row] for row in dots] + + +def frames_in(gram, live): + frames = [] + + def extend(prefix, candidates): + if len(prefix) == 8: + frames.append(prefix) + return + if len(prefix) + len(candidates) < 8: + return + for pos, i in enumerate(candidates): + extend(prefix + [i], [j for j in candidates[pos+1:] if gram[i][j] == 0]) + + extend([], sorted(live)) + return frames + + +def rank_mod(rows): + """Modular nonzero minors certify lower bounds on rational rank only.""" + basis = {} + for row in rows: + v = [x % PRIME for x in row] + for col, b in sorted(basis.items()): + if v[col]: + a = v[col] + v = [(x-a*y) % PRIME for x, y in zip(v, b)] + col = next((c for c, x in enumerate(v) if x), None) + if col is not None: + scale = pow(v[col], -1, PRIME) + basis[col] = [x*scale % PRIME for x in v] + return len(basis) + + +def graph_checks(gram, pivot, supports, frames): + results = [] + for k, ell in itertools.combinations(pivot, 2): + vertices = sorted(set(supports[k]) & set(supports[ell])) + require(vertices, 'empty pair graph') + vertex_set = set(vertices) + edges = set() + for frame in frames: + hit = sorted(vertex_set.intersection(frame)) + if len(hit) == 2: + i, j = hit + require(gram[i][k]*gram[i][ell] + gram[j][k]*gram[j][ell] == 0, + 'edge sign identity') + edges.add((i, j)) + adjacency = {i: set() for i in vertices} + for i, j in edges: + adjacency[i].add(j) + adjacency[j].add(i) + reached = {vertices[0]} + todo = [vertices[0]] + while todo: + for i in adjacency[todo.pop()] - reached: + reached.add(i) + todo.append(i) + require(len(reached) == len(vertices), f'disconnected graph {k},{ell}') + results.append({'pair': [k, ell], 'vertices': len(vertices), 'edges': len(edges), + 'edges_sha256': digest(sorted(edges))}) + return results + + +def evaluate(data): + require(all(PRIME % d for d in range(2, math.isqrt(PRIME)+1)), 'modulus not prime') + roots, gram = root_model() + all_frames = frames_in(gram, range(120)) + require(len(all_frames) == 2025, 'full frame count') + frame0, pivot = data['frame0'], data['pivot'] + require(frame0 in all_frames and pivot in all_frames, 'not a genuine frame') + deleted = data['deleted_lines'] + require(len(deleted) == len(set(deleted)) == 5 and set(deleted) <= set(range(120)), + 'invalid deletion') + require(not set(deleted) & set(frame0), 'deletion already punctured') + live = set(range(120)) - set(frame0) - set(deleted) + require(set(pivot) <= live and len(live) == 107, 'deleted pivot') + live_frames = [f for f in all_frames if set(f) <= live] + supports = {k: [i for i in sorted(live-set(pivot)) if gram[i][k]] for k in pivot} + k = data['coordinate'] + require(k in pivot, 'coordinate outside pivot') + negatives = data['negative_lines'] + require(len(negatives) == len(set(negatives)) and set(negatives) <= set(supports[k]), + 'unknown/duplicate negative line') + q = {i: -1 if i in negatives else 1 for i in supports[k]} + selected = [f for f in live_frames if sum(q.get(i, 0) for i in f) == 0] + require(pivot in selected, 'pivot not selected') + graphs = graph_checks(gram, pivot, supports, selected) + graph_checks(gram, pivot, supports, live_frames) # full-family positive control + ranks = [] + for kk in pivot: + columns = supports[kk] + kernels = [[gram[i][kk]*gram[i][ell] for i in columns] + for ell in pivot if ell != kk] + require(rank_mod(kernels) == 7, 'canonical kernel independence') + # Direct integer products give an upper bound valid over Q and any + # characteristic-zero field. The modular rank supplies the lower bound. + matrices = [[[int(i in f) for i in columns] for f in fs] + for fs in (selected, live_frames)] + for matrix in matrices: + require(all(sum(a*b for a, b in zip(row, h)) == 0 + for row in matrix for h in kernels), 'canonical vector not in kernel') + extra = [q[i] for i in columns] if kk == k else None + if extra is not None: + require(rank_mod(kernels + [extra]) == 8, 'extra vector in canonical span') + require(all(sum(a*b for a, b in zip(row, extra)) == 0 for row in matrices[0]), + 'extra vector not in selected kernel') + require(any(sum(a*b for a, b in zip(row, extra)) != 0 for row in matrices[1]), + 'full-family control failed to remove extra vector') + selected_rank, full_rank = map(rank_mod, matrices) + require(selected_rank == len(columns) - (8 if kk == k else 7), + 'selected lower/upper rank bounds do not meet') + require(full_rank == len(columns)-7, 'complete-family (D) positive control') + ranks.append({'coordinate': kk, 'columns': len(columns), 'selected_rank': selected_rank, + 'full_rank': full_rank, 'required_D_rank': len(columns)-7}) + # Local failure control: a real pivot alone must not pass connectivity. + try: + graph_checks(gram, pivot, supports, [pivot]) + except ValueError: + pass + else: + raise ValueError('pivot-only disconnected control accepted') + violating = next(f for f in live_frames if sum(q.get(i, 0) for i in f)) + repaired = selected + [violating] + repair_ranks = [rank_mod([[int(i in f) for i in supports[kk]] for f in repaired]) + for kk in pivot] + require(repair_ranks == [len(supports[kk])-7 for kk in pivot], + 'one-frame repair does not saturate all diagonal ranks') + return {'root_order_sha256': digest(roots), 'all_frames': len(all_frames), + 'live_frames': len(live_frames), 'selected_frames': len(selected), + 'selected_frames_sha256': digest(selected), 'graphs': graphs, 'ranks': ranks, + 'full_family_q_obstruction': {'frame': violating, + 'sum': sum(q.get(i, 0) for i in violating)}, + 'one_frame_repair_ranks': repair_ranks, + 'scope': 'selected subfamily only; all-live-frame implication remains open'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--certificate', type=Path, default=HERE / 'CERTIFICATE.json') + parser.add_argument('--write', action='store_true', help='regenerate deterministic result after checks') + args = parser.parse_args() + data = json.loads(args.certificate.read_text(encoding='utf-8')) + result = evaluate(data) + if args.write: + data['result'] = result + args.certificate.write_text(json.dumps(data, indent=2) + '\n', encoding='utf-8') + else: + require(result == data['result'], 'certificate result mismatch') + row = next(r for r in result['ranks'] if r['coordinate'] == data['coordinate']) + print('PASS_E8_CONNECTIVITY_INCIDENCE_BOUNDARY ' + f"live={result['live_frames']} selected={result['selected_frames']} " + f"graphs={len(result['graphs'])} rank={row['selected_rank']} " + f"required={row['required_D_rank']} canonical_kernel=7 extra_kernel=1 " + 'full_family_control=PASS one_frame_repair=PASS') + + +if __name__ == '__main__': + try: + main() + except (ValueError, KeyError, TypeError) as error: + raise SystemExit('FAIL_E8_CONNECTIVITY_INCIDENCE_BOUNDARY: ' + str(error))