From 9edc051dbf0036678c475b9dda92fc2b35a5edf8 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 18:32:03 +1100 Subject: [PATCH 1/2] Audit common24 P112 via the complete colored completion matching --- research/p112-common24-graph-audit/PROOF.md | 172 +++++++++++++++ research/p112-common24-graph-audit/README.md | 77 +++++++ .../p112-common24-graph-audit/RESULT.json | 109 ++++++++++ .../p112-common24-graph-audit/REVIEWED.json | 18 ++ .../p112-common24-graph-audit/SOURCES.json | 30 +++ research/p112-common24-graph-audit/TASK.json | 92 ++++++++ .../p112-common24-graph-audit/VERIFY.json | 36 ++++ .../test_controls.py | 81 +++++++ research/p112-common24-graph-audit/verify.py | 202 ++++++++++++++++++ 9 files changed, 817 insertions(+) create mode 100644 research/p112-common24-graph-audit/PROOF.md create mode 100644 research/p112-common24-graph-audit/README.md create mode 100644 research/p112-common24-graph-audit/RESULT.json create mode 100644 research/p112-common24-graph-audit/REVIEWED.json create mode 100644 research/p112-common24-graph-audit/SOURCES.json create mode 100644 research/p112-common24-graph-audit/TASK.json create mode 100644 research/p112-common24-graph-audit/VERIFY.json create mode 100644 research/p112-common24-graph-audit/test_controls.py create mode 100644 research/p112-common24-graph-audit/verify.py diff --git a/research/p112-common24-graph-audit/PROOF.md b/research/p112-common24-graph-audit/PROOF.md new file mode 100644 index 0000000000..f8abce26d7 --- /dev/null +++ b/research/p112-common24-graph-audit/PROOF.md @@ -0,0 +1,172 @@ +# Independent graph audit of the common24 application + +This audits PR3960 at `7e8d98e351ac153d81943218bf168dc8548b1cea`. +It finds no mathematical defect in the stated theorem or the two transfers. +The new finite result is stronger structure of the **complete colored +completion graph**: it is a matching with 2,884 edges and 448 isolated vertices. +This gives an alternative proof of the common-cut coverage step. It does not +establish independent human review or formal-kernel verification. + +## 1. Exactly which finite objects are checked + +Write R for the 120 oriented doubled E8 root lines, F for the eight frame +lines `2e_0 +/- 2e_1,...,2e_6 +/- 2e_7`, and P=R\F. The live table and simple +system are canonical-main inputs. A fresh rational Gauss-Jordan calculation +recovers integral simple coordinates and the original labels +`ell(r)=(1,c(r) mod 2)` in F2^9. The verifier checks the full E8 shell, original +row-label binding, distinct labels and live Gram matrix `112 I_8`. No +predecessor executable is imported. + +A two-dimensional binary annihilator has exactly three nonzero elements +`a,b,a+b`. Sort them. Its unique first two satisfy `a=5. Assume the +binary ranks of their actual support labels are bounded respectively by + + 2,2,2,2,3,5,7,7,7,7,7 + 2,2,2,2,4,4,7,7,7,7,7. + +Ranks2,3,4 give support caps2,4,8 because the labels lie in a leading-one +affine slice. The rank5 cap12 is **inherited from Nick Petalas's global +capacity theorem**, independently checked in PR3951; this audit does not +repeat its 3,309,747-space census. The first caller remains conditional on +that explicitly named dependency. Its six small pieces have capacity sum +`4*2+4+12=24`; the second has `4*2+8+8=24` and needs no rank5 capacity. +The original TWOSIDE status and necessary-filter membership are inherited +from PR3960 and PR3154/3282, rather than recounted as new inventory results. + +Let A=span(p_1,...,p_6) and S the ONE actual union of their supports. Then +|S|<=24. Every element of A is supported in S, so distance53 gives A intersect +C=0. Since A has dimension6, its quotient image in T/D is independent. On +the other hand dim(T/D)<=11-5=6. Hence its dimension is exactly6, A maps +isomorphically to T/D, and dim D=5. + +For each j=7,...,11 there is a unique a_j in A with c_j=p_j-a_j in D. +If sum(lambda_j*c_j)=0, expansion in the original independent p_i basis has +coefficient lambda_j on p_j for every j>=7. Thus all lambda_j vanish: the +five c_j are independent, regardless of the arbitrary coefficients of a_j, +intersections between supports, or cancellations inside S. Evaluation +injectivity gives five independent normals h_j. Outside S, c_j equals p_j, +so its residual label rank is at most7. The common24 bound limits their span +to dimension2, contradiction. This proves exactly these two transfers. + +The executable receipt records graph facts and small caller arithmetic. +It does not turn this written coefficient argument into formal verification. + +## 5. Scope, credit and remaining obligations + +This is a fresh computational and written audit in the same donor/assistant +context as PR3960. It adds the complete matching certificate and a different +finite-space enumerator. It does not claim independent human acceptance, +a full C5 theorem, the full (5,6) cell, a decoder floor, supplier admission, +or a change to the selected kappa. The field proof rechecks and explains +PR3951/3960's argument; its underlying idea is credited there, not claimed +as new here. + +Credit Nick Petalas for global capacities and the E8/root-shortening/shared- +cut predecessors, DreamingOfClouds for PR3154/TWOSIDE/C5, David Arias for the +quadratic model, joaqcoo and the retained E8/P112 lineage. The same donor's +PR3931, PR3951 and PR3960 retain their respective earlier results. New audit: +Chris R / Clear1nsight with substantial OpenAI Codex assistance, Apache-2.0. diff --git a/research/p112-common24-graph-audit/README.md b/research/p112-common24-graph-audit/README.md new file mode 100644 index 0000000000..ee02b2dd3c --- /dev/null +++ b/research/p112-common24-graph-audit/README.md @@ -0,0 +1,77 @@ +# Complete colored-graph audit of the common24 P112 theorem + +An independent implementation audit of [PR3960](https://github.com/CrocSwap/integer-mult-bounds/pull/3960) +at `7e8d98e351ac153d81943218bf168dc8548b1cea` finds no defect in its common24 +theorem or two literal caller transfers. The additional finite result is: +**the entire different-normal completion graph is a matching**, with2,884 +edges and448 isolated vertices among6,216 vertices. A hypothetical three +qualifying directions under one24-site cut would force a triangle. This +replaces the target's specialized small-cut/candidate split with one complete +graph certificate. + +The fresh verifier generates each two-dimensional annihilator by its unique +sorted pair `a 2, 'triangle alone is not a common-cut witness') + edges, triangle, _ = v.graph([(0, 1), (0, 2), (1, 4)], 2) + v.require(len(edges) == 2 and triangle is None, 'same-color edge suppression') + edges, triangle, _ = v.graph([(0, 3), (1, 5), (2, 9)], 3) + v.require(len(edges) == 3 and triangle is not None, 'overlapping-cut triangle control') + # Each two-dimensional annihilator has three nonzero elements and exactly + # one sorted representative a= 0 for x in c) or all(x <= 0 for x in c) for c in coords), 'simple signs') + labels = [1+sum((x%2) << (j+1) for j, x in enumerate(c)) for c in coords] + require(len(set(labels)) == 120, 'label injectivity') + live_mask = sum(1 << i for i, r in enumerate(roots) if r not in frame) + require([x for i, x in enumerate(labels) if live_mask >> i & 1] == list(map(int, table[0].split())), 'original row-label binding') + require([[sum(r[i]*r[j] for r in live) for j in range(8)] for i in range(8)] == [[112*(i == j) for j in range(8)] for i in range(8)], 'live Gram injectivity') + signed = set(roots) | {tuple(-x for x in r) for r in roots} + for alpha in simple: + for r in signed: + require(dot(alpha, r)%4 == 0, 'reflection integrality') + require(tuple(x-dot(alpha, r)//4*y for x, y in zip(r, alpha)) in signed, 'reflection closure') + rho = [sum(row) for row in inverse(simple)] + require(all(dot(a, rho) == 1 for a in simple), 'chamber functional') + faces = [[r for r, c in zip(roots, coords) if all(c[j] == 0 for j in range(8) if not mask >> j & 1)] for mask in range(256)] + require(max(len(face) for mask, face in enumerate(faces) if mask.bit_count() <= 6) == 36, 'rank-six face bound') + require([len(faces[255 ^ (1 << j)]) for j in range(8)] == [42, 28, 22, 14, 16, 23, 37, 63], 'seven-node faces') + require(sum(all(dot(r, a) == 0 for a in faces[127]) for r in roots) == 1, 'E7 root normal') + return roots, labels, live_mask + + +def all_flats(labels): + """The unique ordered pair a> i & 1 and dot(r, s))) + require(Counter(x.bit_count() for x in off) == {53: 112, 56: 8}, 'root word distances') + for owner, word in enumerate(off): + for mask in masks: + cut = word & ~mask + if cut.bit_count() <= 24: + records.append((owner, mask, cut)) + records.sort() + vertices = sorted({(owner, cut) for owner, _, cut in records}) + return records, vertices + + +def graph(vertices, cutoff=24): + adjacency = [0]*len(vertices) + edges = [] + for i, (a, s) in enumerate(vertices): + for j in range(i+1, len(vertices)): + b, t = vertices[j] + if a != b and (s | t).bit_count() <= cutoff: + adjacency[i] |= 1 << j + adjacency[j] |= 1 << i + edges.append((i, j)) + triangle = None + for i, j in edges: + common = adjacency[i] & adjacency[j] + if common: + triangle = (i, j, (common & -common).bit_length()-1) + break + degrees = Counter(x.bit_count() for x in adjacency) + return edges, triangle, {str(k): v for k, v in sorted(degrees.items())} + + +def caller_arithmetic(): + caps = {2: 2, 3: 4, 4: 8, 5: 12} # cap12 is inherited, not recertified here. + profiles = [[2, 2, 2, 2, 3, 5, 7, 7, 7, 7, 7], [2, 2, 2, 2, 4, 4, 7, 7, 7, 7, 7]] + output = [] + for weights in profiles: + required_intersection = 5 + quotient_bound = len(weights)-required_intersection + support_cap = sum(caps[w] for w in weights[:quotient_bound]) + require(support_cap == 24 < 53, 'small basis below distance') + require(weights[quotient_bound:] == [7]*5, 'five rank-seven residual pieces') + output.append({'weights': weights, 'required_intersection': required_intersection, 'quotient_bound': quotient_bound, 'basis_capacity_sum': support_cap, 'independent_residual_codewords': len(weights)-quotient_bound}) + return output + + +def compute(): + roots, labels, live = geometry(sources()) + masks = all_flats(labels) + records, vertices = completions(roots, live, masks) + edges, triangle, degrees = graph(vertices) + require(triangle is None, 'three-color completion triangle') + require(all(int(k) <= 1 for k in degrees), 'complete different-color graph is a matching') + raw = (HERE/'REVIEWED.json').read_bytes() + require(hashlib.sha256(raw).hexdigest() == REVIEWED_SHA, 'reviewed target identity') + target = json.loads(raw, object_pairs_hook=unique)['compared_fields'] + require(digest(sorted(Counter(masks).items())) == target['flat_inventory_digest'], 'target flat disagreement') + require(digest(records) == target['critical_record_digest'] and len(records) == target['critical_records'], 'target record disagreement') + require(edges, 'two-direction witness missing') + i, j = edges[0] + a, s = vertices[i] + b, t = vertices[j] + require(dot(roots[a], roots[a])*dot(roots[b], roots[b])-dot(roots[a], roots[b])**2 > 0, 'independent witness normals') + return {'seven_spaces': len(masks), 'flat_multiset_sha256': digest(sorted(Counter(masks).items())), 'completion_records': len(records), 'completion_records_sha256': digest(records), 'colored_vertices': len(vertices), 'vertices_sha256': digest(vertices), 'different_color_edges': len(edges), 'edge_sha256': digest(edges), 'degree_histogram': degrees, 'triangles': 0, 'witness': {'normal_indices': [a, b], 'normals': [list(roots[a]), list(roots[b])], 'cut_labels': [label for k, label in enumerate(labels) if (s | t) >> k & 1]}, 'caller_arithmetic': caller_arithmetic()} + + +def main(): + require(not sys.argv[1:], 'no arguments accepted') + observed = compute() + require(digest(observed) == digest(read_json(HERE/'RESULT.json')), 'audit result receipt mismatch') + print('PASS_COMMON24_GRAPH_AUDIT spaces=43435 records=6216 triangles=0 callers=2') + + +if __name__ == '__main__': + main() From b71bb48a96acb2a010a8552e85a52411339263d0 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 18:33:51 +1100 Subject: [PATCH 2/2] Correct coordinated Discussion snapshot time to 07:24 UTC --- research/p112-common24-graph-audit/TASK.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/p112-common24-graph-audit/TASK.json b/research/p112-common24-graph-audit/TASK.json index febcd3f261..58bbce8da8 100644 --- a/research/p112-common24-graph-audit/TASK.json +++ b/research/p112-common24-graph-audit/TASK.json @@ -80,7 +80,7 @@ "priority_revision": 6, "entry_open_PR_bodies": 671, "entry_PR_snapshot_UTC": "2026-10-19 07:22 UTC", - "Discussion_coverage": "Parent reviewed rendered C5/start-here/handoff/active board at07:27 UTC; partial, not all-Discussion API coverage. No overlapping common24 audit found.", + "Discussion_coverage": "Parent reviewed rendered C5/start-here/handoff/active board at07:24 UTC; partial, not all-Discussion API coverage. No overlapping common24 audit found.", "selected_frontier_unchanged": true, "final_open_PR_bodies": 673, "final_PR_snapshot_UTC": "2026-10-19 07:30:28 UTC",