diff --git a/research/e8-hyperplane-minrank/README.md b/research/e8-hyperplane-minrank/README.md new file mode 100644 index 0000000000..e529071398 --- /dev/null +++ b/research/e8-hyperplane-minrank/README.md @@ -0,0 +1,65 @@ +# A thirteen-line certificate for the E8 hyperplane floor + +For every proper real linear hyperplane H in the eight-dimensional E8 +root space, every binary fitting matrix on the root lines outside H has +rank at least nine. The fitting convention is diagonal one and entry +zero for each distinct pair with nonzero real inner product. Entries on +orthogonal pairs are free. Symmetry is not assumed. This floor is prior work: [PR #3045](https://github.com/CrocSwap/integer-mult-bounds/pull/3045) +proves the stronger mixed-normal statement in +[Theorem 6 at its pinned source](https://github.com/CrocSwap/integer-mult-bounds/blob/16feea078f5542964ae85ca1b1f35bb94314ae78/research/nondense-pairing-square-floors/README.md). +Set its two real normals equal. This annex supplies compact explicit +thirteen-line certificates and a separate Schur-complement proof for that +established slice, with no SAT solver in the replay. It claims no new +floor, comparison of verification speed, circuit or kappa gain. + +The [proof](historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md) +uses a thirteen-line certificate in each of eight maximal parabolic +complements. Eight anchors have identity fitting block. Five witnesses +encode five edges on four anchor indices. A rank-eight Schur factorization +would orient each edge toward its unique nonzero binary product. Incident +edges cannot share an endpoint, which is impossible for five edges on four +vertices. The Weyl-chamber argument then covers every real hyperplane. + +The later [dense-table rigidity theorem](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/decoder-floors-frontier-format/README.md) +and [tensor copy-floor theorem](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/tensor-e8-copy-floor/README.md) +cover the earlier full-E8 rank-nine support and minimum-nine-term cost +consequences. Those consequences are not new claims here. This annex +preserves an alternative proof of the induced-complement theorem: its matrix need only +fit the lines outside H and need not extend to a rank-nine full-E8 matrix. +The other new E8 small-redundancy package fixes the canonical full matrix; +it does not prove this arbitrary fitting statement on each complement. + +From this package directory, with Python 3.10 or later: + +```sh +python3 -B verify.py --build /tmp/e8-hyperplane-minrank-replay +``` + +The output path must not exist. Only the standard library is required. +The final line must be: + +```text +PASS_E8_HYPERPLANE_MINRANK 240 8 13 +``` + +The independent checker constructs all 240 signed roots, checks the simple +basis, integral positive/negative root coordinates and simple reflections, +and verifies all eight thirteen-line certificates by integer arithmetic. +It compares the complete result with the saved receipt. The wrapper rejects +optimized Python and runs the child with Python environment options ignored. +No search runs. The written Weyl-chamber and Schur-complement arguments are +necessary proof steps; the finite replay alone does not prove the theorem. + +`SOURCE-MANIFEST.json` binds the unchanged proof, certificate and checker. +`replayed-receipt.json` and `replay.log` record the fresh cleanup replay. +The standalone proof uses the standard E8 root system and the existing +local 13-line fitting certificate. The original local proof and checks were +prepared with substantial OpenAI Codex and research-agent assistance under +the user's direction. No independent human review is claimed. + +## Open next questions + +Can an induced E8 set with no such thirteen-line certificate have binary +fitting rank below nine? A first step is to compare a specified removed set +with the eight stored certificates. This package makes no assertion about +arbitrary punctures, larger fields, or a physical construction. diff --git a/research/e8-hyperplane-minrank/SOURCE-MANIFEST.json b/research/e8-hyperplane-minrank/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..c30336672f --- /dev/null +++ b/research/e8-hyperplane-minrank/SOURCE-MANIFEST.json @@ -0,0 +1,29 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "original": "work/p518-next/bit/weighted/rank9/quick.json", + "package": "historical/work/p518-next/bit/weighted/rank9/quick.json", + "sha256": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "bytes": 15906 + }, + { + "original": "work/p518-next/bit/weighted/rank9/parabolic/PROOF.md", + "package": "historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md", + "sha256": "c4f7fbe4851d52e4f7daf6389e2b2b0ad758bb9a9cf5be60a70df3234b2ecb67", + "bytes": 4259 + }, + { + "original": "work/p518-next/bit/weighted/rank9/parabolic/independent_check.py", + "package": "historical/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py", + "sha256": "8c41c12c044ab5bc515a1f6f1dc44dce6550ff3051f77262942873f5e5bb5f45", + "bytes": 4072 + }, + { + "original": "work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json", + "package": "historical/work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json", + "sha256": "b80c137491fe45c4e7c8a28987581047fb05ca139685d14c094e43f23b6fc1e7", + "bytes": 1599 + } + ] +} diff --git a/research/e8-hyperplane-minrank/VALIDATION.json b/research/e8-hyperplane-minrank/VALIDATION.json new file mode 100644 index 0000000000..91fabeea5a --- /dev/null +++ b/research/e8-hyperplane-minrank/VALIDATION.json @@ -0,0 +1,18 @@ +{ + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "command": [ + "python3", + "-E", + "-B", + "work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank/verify.py", + "--build", + "/tmp/e8-hyperplane-cleanup-20261023" + ], + "exit_code": 0, + "fresh_output_required": true, + "log": "replay.log", + "log_sha256": "b2e9cbe5c104028fd32942d900443b30debcf7dbd7bd8b7e05ea14400429b376", + "receipt": "replayed-receipt.json", + "receipt_sha256": "b80c137491fe45c4e7c8a28987581047fb05ca139685d14c094e43f23b6fc1e7", + "note": "Literal output is retained. Original source files are unchanged. No new discovery search ran." +} diff --git a/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json new file mode 100644 index 0000000000..4f2cf060cb --- /dev/null +++ b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json @@ -0,0 +1,66 @@ +{ + "status": "PASS", + "input_sha256": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "integer_root_count": 240, + "simple_basis_and_reflection_checks": true, + "all_eight_certificates_checked": true, + "parabolics": [ + { + "node": 1, + "type": "D7", + "root_lines_inside": 42, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 2, + "type": "A7", + "root_lines_inside": 28, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 3, + "type": "A6+A1", + "root_lines_inside": 22, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 4, + "type": "A4+A2+A1", + "root_lines_inside": 14, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 5, + "type": "A4+A3", + "root_lines_inside": 16, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 6, + "type": "D5+A2", + "root_lines_inside": 23, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 7, + "type": "E6+A1", + "root_lines_inside": 37, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 8, + "type": "E7", + "root_lines_inside": 63, + "certificate_lines": 13, + "incident_zero_constraints": 8 + } + ], + "scope": "Finite certificates and simple roots. The universal theorem also uses the Weyl chamber and fitting rank arguments in PROOF.md." +} diff --git a/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md new file mode 100644 index 0000000000..58fd0b1879 --- /dev/null +++ b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md @@ -0,0 +1,91 @@ +# A rank-nine obstruction after each hyperplane removal + +Let R be the 120 E8 root lines. A binary fitting matrix F has F(r,r)=1. +For distinct roots r,s with r dot s nonzero, it has F(r,s)=0. Entries for +orthogonal roots are free. The matrix need not be symmetric. + +For every linear hyperplane H through the origin, the fitting matrices +on R outside H have binary rank at least nine. The finite part of this +statement uses eight certificates in `../quick.json`. Each certificate +has thirteen root lines. `independent_check.py` checks each certificate +with integer arithmetic. It also checks the simple-root basis and the +root counts. `INDEPENDENT.json` records the result and the input hash. + +## The thirteen-root certificate + +The first eight roots are pairwise nonorthogonal anchors. Their fitting +block is the identity I8. Each of the five other roots is a witness for a +distinct pair of anchors. It is orthogonal to exactly those two anchors. +The five pairs use only four anchor indices. Witnesses for incident pairs +are nonorthogonal. + +Suppose the fitting matrix on these thirteen roots has rank at most eight. +Write it in block form as [[I8,B],[C,D]]. The Schur complement gives D=CB. +For the witness for e={i,j}, its column in B and its row in C have support +contained in {i,j}. Its diagonal entry gives + + C[e,i] B[i,e] + C[e,j] B[j,e] = 1. + +Over F2, exactly one product is one. Assign the pair to that endpoint. +If two incident pairs e,f are assigned to their common endpoint i, then + + (CB)[e,f] = C[e,i] B[i,f] = 1. + +Their witnesses are nonorthogonal, so D[e,f] must be zero. This is a +contradiction. Each of the four endpoints can receive at most one pair. +There are five pairs. Thus the fitting rank is at least nine. + +## The eight maximal parabolic subsystems + +Use the simple roots in `../quick.json`. Their Dynkin edges are +1-3, 2-4, 3-4, 4-5, 5-6, 6-7, and 7-8. All roots are scaled by two. +Delete one simple root at a time. The types and root-line counts are: + +| Deleted node | Type | Root lines | +| --- | --- | ---: | +| 1 | D7 | 42 | +| 2 | A7 | 28 | +| 3 | A6+A1 | 22 | +| 4 | A4+A2+A1 | 14 | +| 5 | A4+A3 | 16 | +| 6 | D5+A2 | 23 | +| 7 | E6+A1 | 37 | +| 8 | E7 | 63 | + +For each row, its certificate has all thirteen roots outside the span of +the retained seven simple roots. The normal in the input is orthogonal +to those seven roots and has nonzero inner product with the deleted root. +Thus each of the eight complements has fitting rank at least nine. + +## All hyperplanes + +Write H=v-perp, where v is nonzero. A Weyl transformation puts v in the +closed dominant chamber. In that chamber each simple-root inner product +is nonnegative. A positive root is a sum of simple roots with nonnegative +integer coefficients. Its inner product with v is zero exactly when each +simple root in its support has zero inner product with v. + +Thus the roots in H form a standard parabolic subsystem after that Weyl +transformation. Since v is nonzero and the simple roots span the ambient +space, at least one simple-root inner product is positive. Delete such a +node. The roots in H lie in the rank-seven subsystem for that deletion. +The complement of H therefore contains the complement of that subsystem. +Fitting rank cannot decrease when more vertices are present, since the +smaller fitting matrix is a principal submatrix. Weyl transformations +preserve orthogonality. The eight finite certificates now give the claim. +This argument also applies to real hyperplanes. + +## Consequence for rank-nine fitting matrices + +Let F be a fitting matrix on all 120 roots, with binary rank nine. For a +proper hyperplane H, let O be the indices outside H. The principal matrix +F[O,O] has rank at least nine, and hence exactly nine. The rows F[O,*] +therefore span the complete row space of F. The columns F[*,O] span the +complete column space. + +If a column-space vector Fu has support in H, then F[O,*]u=0. Since those +rows span all rows, Fu=0. Apply the transpose argument to the row space. +Consequently, every nonzero vector in either space has support with +rational span dimension eight. In particular, a rank-nine factorization +cannot have a nonzero factor row or column with support rank at most seven. +This does not rule out factorizations with more than nine factors. diff --git a/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py new file mode 100644 index 0000000000..4ec1c968e5 --- /dev/null +++ b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py @@ -0,0 +1,95 @@ +"""Check the eight finite certificates with integer arithmetic.""" +from fractions import Fraction +from itertools import combinations, product +from pathlib import Path +import hashlib +import json + +BASE = Path(__file__).resolve().parent +source = BASE.parent / 'quick.json' +raw = source.read_bytes() +data = json.loads(raw) +roots = set() +for i in range(8): + for j in range(i + 1, 8): + for u, v in product((-2, 2), repeat=2): + row = [0] * 8 + row[i], row[j] = u, v + roots.add(tuple(row)) +roots.update(row for row in product((-1, 1), repeat=8) + if row.count(-1) % 2 == 0) +assert len(roots) == 240 +simple = [(1,-1,-1,-1,-1,-1,-1,1), (2,2,0,0,0,0,0,0), + (-2,2,0,0,0,0,0,0)] +for j in range(1, 6): + row = [0] * 8 + row[j], row[j + 1] = -2, 2 + simple.append(tuple(row)) +assert data['simple_roots'] == list(map(list, simple)) +assert all(root in roots for root in simple) + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + +# Invert the column matrix of the simple roots. +matrix = [[Fraction(simple[j][i]) for j in range(8)] + + [Fraction(i == j) for j in range(8)] for i in range(8)] +for j in range(8): + pivot = next(i for i in range(j, 8) if matrix[i][j]) + matrix[j], matrix[pivot] = matrix[pivot], matrix[j] + scale = matrix[j][j] + matrix[j] = [x / scale for x in matrix[j]] + for i in range(8): + if i != j: + scale = matrix[i][j] + matrix[i] = [x - scale * y for x, y in zip(matrix[i], matrix[j])] +inverse = [row[8:] for row in matrix] +for root in roots: + coordinates = [dot(row, root) for row in inverse] + assert all(x.denominator == 1 for x in coordinates) + assert all(x >= 0 for x in coordinates) or all(x <= 0 for x in coordinates) + for alpha in simple: + inner = dot(root, alpha) + assert inner % 4 == 0 + reflected = tuple(x - inner // 4 * y for x, y in zip(root, alpha)) + assert reflected in roots +assert all(dot(alpha, alpha) == 8 for alpha in simple) +cartan = [[dot(a, b) // 4 for b in simple] for a in simple] +assert [(i + 1, j + 1) for i, j in combinations(range(8), 2) + if cartan[i][j] == -1] == [(1,3),(2,4),(3,4),(4,5),(5,6),(6,7),(7,8)] + +pairs = [tuple(pair) for pair in data['pairs']] +assert len(pairs) == 5 and len(set(pairs)) == 5 +assert len(set().union(*map(set, pairs))) == 4 +counts = [42,28,22,14,16,23,37,63] +types = ['D7','A7','A6+A1','A4+A2+A1','A4+A3','D5+A2','E6+A1','E7'] +items = [] +assert len(data['parabolics']) == 8 +for item in data['parabolics']: + node = item['node'] + n = item['normal'] + assert [i + 1 for i, a in enumerate(simple) if dot(n, a)] == [node] + inside = sum(dot(n, r) == 0 for r in roots) // 2 + assert inside == item['roots_in_hyperplane'] == counts[node - 1] + rows = list(map(tuple, item['certificate'])) + assert len(rows) == 13 + assert len({min(r, tuple(-x for x in r)) for r in rows}) == 13 + assert all(r in roots and dot(r, n) != 0 for r in rows) + anchors, witnesses = rows[:8], rows[8:] + assert all(dot(a, b) != 0 for a, b in combinations(anchors, 2)) + for pair, witness in zip(pairs, witnesses): + assert tuple(i for i, a in enumerate(anchors) if dot(a, witness) == 0) == pair + checks = 0 + for (p, u), (q, v) in combinations(list(zip(pairs, witnesses)), 2): + if set(p) & set(q): + assert dot(u, v) != 0 + checks += 1 + assert checks == 8 + items.append({'node':node, 'type':types[node - 1], 'root_lines_inside':inside, + 'certificate_lines':13, 'incident_zero_constraints':checks}) +result = {'status':'PASS', 'input_sha256':hashlib.sha256(raw).hexdigest(), + 'integer_root_count':240, 'simple_basis_and_reflection_checks':True, + 'all_eight_certificates_checked':True, 'parabolics':items, + 'scope':'Finite certificates and simple roots. The universal theorem also uses the Weyl chamber and fitting rank arguments in PROOF.md.'} +(BASE / 'INDEPENDENT.json').write_text(json.dumps(result, indent=2) + '\n') +print(json.dumps(result, indent=2)) diff --git a/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/quick.json b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/quick.json new file mode 100644 index 0000000000..d00b91cd06 --- /dev/null +++ b/research/e8-hyperplane-minrank/historical/work/p518-next/bit/weighted/rank9/quick.json @@ -0,0 +1,1284 @@ +{ + "simple_roots": [ + [ + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 1 + ], + [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + -2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -2, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -2, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -2, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + -2, + 2, + 0 + ] + ], + "pairs": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "parabolics": [ + { + "node": 1, + "normal": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4 + ], + "roots_in_hyperplane": 42, + "trials": 58, + "certificate": [ + [ + 1, + -1, + 1, + -1, + 1, + 1, + -1, + -1 + ], + [ + -1, + -1, + 1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + -2, + 0, + 0, + 0, + -2 + ], + [ + -1, + -1, + -1, + -1, + 1, + 1, + -1, + -1 + ], + [ + 0, + 0, + -2, + 0, + 0, + 0, + 0, + -2 + ], + [ + -1, + -1, + -1, + -1, + -1, + 1, + 1, + -1 + ], + [ + -1, + -1, + -1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + -1, + -1 + ] + ] + }, + { + "node": 2, + "normal": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 5 + ], + "roots_in_hyperplane": 28, + "trials": 0, + "certificate": [ + [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1 + ] + ] + }, + { + "node": 3, + "normal": [ + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 7 + ], + "roots_in_hyperplane": 22, + "trials": 30, + "certificate": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 2 + ], + [ + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + -1, + 1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 2 + ], + [ + -1, + -1, + 1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + [ + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1 + ], + [ + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1 + ], + [ + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 2 + ] + ] + }, + { + "node": 4, + "normal": [ + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 10 + ], + "roots_in_hyperplane": 14, + "trials": 4, + "certificate": [ + [ + 0, + 0, + 0, + 0, + 0, + -2, + -2, + 0 + ], + [ + -1, + -1, + 1, + -1, + -1, + -1, + -1, + 1 + ], + [ + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1 + ], + [ + -1, + -1, + 1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + -2, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + -1, + -1, + -1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 0, + -2, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + -2, + 0, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1 + ] + ] + }, + { + "node": 5, + "normal": [ + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 8 + ], + "roots_in_hyperplane": 16, + "trials": 38, + "certificate": [ + [ + 0, + 0, + -2, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + -2, + 0, + 0, + -2 + ], + [ + 1, + 1, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1 + ], + [ + 0, + 0, + -2, + 0, + -2, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + -1, + 1, + -1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + -2, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -2, + -2, + 0, + 0 + ], + [ + 0, + 0, + -2, + -2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -2, + 0, + 0, + -2, + 0, + 0 + ] + ] + }, + { + "node": 6, + "normal": [ + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 6 + ], + "roots_in_hyperplane": 23, + "trials": 21, + "certificate": [ + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + -1, + -1 + ], + [ + -1, + -1, + -1, + 1, + -1, + 1, + -1, + -1 + ], + [ + -1, + 1, + -1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + -1, + -1 + ], + [ + 0, + 0, + -2, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + -2, + 0, + 0, + -2 + ], + [ + -1, + 1, + -1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + -2 + ] + ] + }, + { + "node": 7, + "normal": [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 4 + ], + "roots_in_hyperplane": 37, + "trials": 22, + "certificate": [ + [ + -1, + -1, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + -1, + -1, + -1, + 1, + -1, + 1, + 1, + 1 + ], + [ + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 2 + ], + [ + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2 + ], + [ + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 2 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 2 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 2 + ] + ] + }, + { + "node": 8, + "normal": [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2 + ], + "roots_in_hyperplane": 63, + "trials": 72, + "certificate": [ + [ + -2, + 0, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + -2, + 0, + 0, + -2 + ], + [ + 0, + -2, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2 + ], + [ + 0, + 0, + 0, + -2, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + -2, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + -2, + 0, + -2 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + -2 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + -2 + ] + ] + } + ] +} diff --git a/research/e8-hyperplane-minrank/replay.log b/research/e8-hyperplane-minrank/replay.log new file mode 100644 index 0000000000..49a559f97b --- /dev/null +++ b/research/e8-hyperplane-minrank/replay.log @@ -0,0 +1,2 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /private/tmp/e8-hyperplane-cleanup-20261023/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py +PASS_E8_HYPERPLANE_MINRANK 240 8 13 diff --git a/research/e8-hyperplane-minrank/replayed-receipt.json b/research/e8-hyperplane-minrank/replayed-receipt.json new file mode 100644 index 0000000000..4f2cf060cb --- /dev/null +++ b/research/e8-hyperplane-minrank/replayed-receipt.json @@ -0,0 +1,66 @@ +{ + "status": "PASS", + "input_sha256": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "integer_root_count": 240, + "simple_basis_and_reflection_checks": true, + "all_eight_certificates_checked": true, + "parabolics": [ + { + "node": 1, + "type": "D7", + "root_lines_inside": 42, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 2, + "type": "A7", + "root_lines_inside": 28, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 3, + "type": "A6+A1", + "root_lines_inside": 22, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 4, + "type": "A4+A2+A1", + "root_lines_inside": 14, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 5, + "type": "A4+A3", + "root_lines_inside": 16, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 6, + "type": "D5+A2", + "root_lines_inside": 23, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 7, + "type": "E6+A1", + "root_lines_inside": 37, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 8, + "type": "E7", + "root_lines_inside": 63, + "certificate_lines": 13, + "incident_zero_constraints": 8 + } + ], + "scope": "Finite certificates and simple roots. The universal theorem also uses the Weyl chamber and fitting rank arguments in PROOF.md." +} diff --git a/research/e8-hyperplane-minrank/review/HISTORICAL-INPUT-HASHES.json b/research/e8-hyperplane-minrank/review/HISTORICAL-INPUT-HASHES.json new file mode 100644 index 0000000000..95a2b3773f --- /dev/null +++ b/research/e8-hyperplane-minrank/review/HISTORICAL-INPUT-HASHES.json @@ -0,0 +1,6 @@ +{ + "quick.json": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "parabolic/PROOF.md": "c4f7fbe4851d52e4f7daf6389e2b2b0ad758bb9a9cf5be60a70df3234b2ecb67", + "parabolic/independent_check.py": "8c41c12c044ab5bc515a1f6f1dc44dce6550ff3051f77262942873f5e5bb5f45", + "parabolic/INDEPENDENT.json": "b80c137491fe45c4e7c8a28987581047fb05ca139685d14c094e43f23b6fc1e7" +} diff --git a/research/e8-hyperplane-minrank/review/INDEPENDENT-REVIEW.md b/research/e8-hyperplane-minrank/review/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..e97764e8d3 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/INDEPENDENT-REVIEW.md @@ -0,0 +1,146 @@ +# Independent review of the E8 hyperplane annex + +Reviewer: the separate OpenAI Codex agent `/root/e8_cost_review`. +Result: **PASS as an alternative proof and certificate annex**. +There is no new floor, supplier, verified speed improvement, or kappa result. +This is an agent review, not independent human review or formal verification. + +The reviewed package is +`work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank`. +`REVIEWED-FILE-HASHES.json` binds all reviewed files. The PR description +standard at `/Users/aliromman/Projects/IntegerMultiplicationBounds/PR-DESCRIPTION-STANDARD.md` +was read before this review. + +## Publication scope and overlap + +For the standard 120 E8 root lines and any proper real linear hyperplane H, +every F2 fitting matrix on the lines outside H has rank at least nine. +Fitting means diagonal one and zero at each distinct nonorthogonal pair. +The entries at orthogonal pairs are free. No symmetry is required. + +This theorem is already implied by DreamingOfClouds' public +[PR #3045](https://github.com/CrocSwap/integer-mult-bounds/pull/3045), +[Theorem 6 at commit 16feea078f5542964ae85ca1b1f35bb94314ae78](https://github.com/CrocSwap/integer-mult-bounds/blob/16feea078f5542964ae85ca1b1f35bb94314ae78/research/nondense-pairing-square-floors/README.md). +That theorem covers the intersection of the two nonzero-normal supports +when their normals have nonzero inner product. Set both normals equal to +the nonzero real normal of H. Their inner product is then positive, and +the intersection is exactly the complement under study. The old local +row-space and column-space consequence also follows by the displayed +linear algebra. No new theorem scope should be attributed to this annex. + +The useful contribution is its explicit small certificate and short proof +of this slice. Each of eight representative complements needs only thirteen +roots. The replay uses integer arithmetic and the standard library, with +no SAT solver or discovery search. No comparative speed measurement was +made. The README now states this scope and credits the stronger public +theorem. The older dense-table and minimum-term consequences are not +claimed as new. + +The overlap check read the exact PR3045 source, searched the current-main +research text at `cef4b52f2a59009865bf8eabde1be3f159063703`, and checked the +315-entry `OPEN-PRS.json` snapshot. The source of the decisive overlap is +PR3045's actual mixed-normal theorem, not its numerical 72 consequence. +The retained package is justified by its alternative proof, not by an +assertion of exhaustive novelty. + +## Proof review + +Each certificate has eight pairwise nonorthogonal anchors. Its anchor +fitting block is I8. Each of the other five roots is orthogonal to exactly +the two anchors specified by its pair. The five distinct pairs use four +anchor indices. Witnesses at incident pairs are nonorthogonal. + +If a fitting matrix had rank at most eight, its I8 Schur complement would +give `D=CB`. The diagonal equation at each witness is the sum of two +binary products and equals one. Exactly one product equals one. Assign +that pair to its endpoint. If two incident pairs had the same assigned +endpoint, the corresponding off-diagonal product in `CB` would be one, +although the fitting condition requires zero. Each endpoint can therefore +receive at most one pair. Five pairs on four endpoints give a contradiction. +The argument permits unrelated C and B and thus does not assume symmetry. + +This step is specific to F2. The assertion that one of two products is +uniquely one must not be transferred to an arbitrary larger field. The +README excludes larger fields and other punctures. + +The eight-case reduction covers all real hyperplanes, including those whose +root intersection has rank below seven. The checker verifies a simple-root +basis, integral single-sign coordinates for every signed root, and closure +under each simple reflection. These reflections generate a finite group: +they permute the finite root set, which spans the ambient space. Choose an +interior chamber vector with positive inner product with each simple root. +On the finite orbit of any normal, maximize its inner product with this +vector. A negative simple-root inner product would permit a reflection that +increases that maximum. Thus an orbit normal lies in the closed dominant +chamber. For a positive root, perpendicularity to that normal forces every +simple root used in its expansion to be perpendicular to the normal. + +The normal is nonzero, so one simple-root inner product is positive. Delete +that node. All roots in the original hyperplane then lie in the associated +seven-simple-root span. The complement of the original hyperplane contains +the tested parabolic complement. A larger fitting matrix has at least the +rank of that principal submatrix. This proves coverage; no enumeration of +sampled normals is being treated as universal evidence. + +For the rank-nine full-matrix consequence, the outside principal block +has rank nine. Its outside rows and columns therefore span the full row +and column spaces. A vector in either space supported inside H must be +zero. Every nonzero row-space or column-space vector consequently has full +rational root support span. This consequence is sound but not a new public +bound, and it says nothing by itself about more than nine factors. + +## Fresh verification + +The frozen historical checker was run in a temporary copy and reproduced +its entire saved receipt. The package wrapper was then run from the +workspace root on CPython 3.14.7: + +```sh +python3 -E -B work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank/verify.py --build /absolute/fresh/output +``` + +The output directory must not already exist. The fresh run returned zero +and printed: + +```text +PASS_E8_HYPERPLANE_MINRANK 240 8 13 +``` + +It ran sequentially and left all package bytes unchanged. +`wrapper-command.json` records the actual command and result. +`HISTORICAL-INPUT-HASHES.json` binds the original proof, certificate, +checker, and receipt. The staged historical files match those originals. +No frozen source was changed. + +A separate script imports no package code. It reconstructs all 240 signed +roots, checks the eight normals, all thirteen roots in each certificate, +the anchor constraints, and every witness support. For each certificate, +it enumerates all `6^5=7776` choices of the B and C witness entries that +satisfy the five binary diagonal equations. None satisfies all required +off-diagonal equations. This gives 62,208 exact Schur checks in total. +For each certificate, the first four witnesses do admit a rank-eight +completion. These positive controls check the five-edge boundary. + +Run the separate controls with: + +```sh +python3 -E -B work/project-final-cleanup-20261022/reviews/e8-parabolic/independent_controls.py work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank --output /absolute/new/result.json +``` + +The final line is: + +```text +PASS_E8_PARABOLIC_INDEPENDENT certificates=8 schur_assignments=62208 rejected=3 +``` + +The three rejection controls cover changed source bytes, a repeated node +with a missing deletion case despite an updated source hash, and optimized +Python mode. The wrapper's explicit node-completeness check resolves the +historical checker's reliance on the saved receipt for that coverage. +The wrapper uses `-E` for its child and rejects `-O` at entry. This is an +explicit supported-mode limit, not an optimized-mode success claim. + +The universal argument remains a written proof supported by finite checks. +No Lean run, prior SAT replay, complete supplier replay, full kappa +calculation, or hosted CI check was performed. The final PR description, +rendered links, and published readback still need the coordinator's checks. diff --git a/research/e8-hyperplane-minrank/review/OVERLAP.json b/research/e8-hyperplane-minrank/review/OVERLAP.json new file mode 100644 index 0000000000..88b803d1c1 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/OVERLAP.json @@ -0,0 +1,20 @@ +{ + "snapshot_sha256": "e0413ab0c3f982d9f35949478226b6617131708fae1469d49e3eb08e82a098e5", + "snapshot_records": 315, + "prior_pr": { + "number": 3045, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3045", + "title": "Non-dense fitting B: every E8 term with x\u00b7y \u2260 0 has rank \u2265 9; square root-code floors E8 \u2265 72, P112 \u2265 64, P104 \u2265 56, D4 \u2265 12 for any fitting B (no \u03ba claim)", + "author": { + "id": "U_kgDOClpS9w", + "is_bot": false, + "login": "DreamingOfClouds", + "name": "" + }, + "headRefOid": "16feea078f5542964ae85ca1b1f35bb94314ae78" + }, + "decisive_source": "https://github.com/CrocSwap/integer-mult-bounds/blob/16feea078f5542964ae85ca1b1f35bb94314ae78/research/nondense-pairing-square-floors/README.md", + "derivation": "Set x=y to any nonzero real hyperplane normal in Theorem6. The nonzero-normal inner product is positive.", + "live_source_read": "Exact pinned README opened with web tool during this review; per-term statement and Lemmas6.1/6.2 read.", + "prior_proof_replayed": false +} diff --git a/research/e8-hyperplane-minrank/review/REVIEWED-FILE-HASHES.json b/research/e8-hyperplane-minrank/review/REVIEWED-FILE-HASHES.json new file mode 100644 index 0000000000..9f942cf5cf --- /dev/null +++ b/research/e8-hyperplane-minrank/review/REVIEWED-FILE-HASHES.json @@ -0,0 +1,12 @@ +{ + "README.md": "6a474ea36f0c70e9d1320dbbc4ebacba3ecec87486f4ca07f98f93c180159776", + "SOURCE-MANIFEST.json": "aa4f8d64db43f10d68c3ed2effc2f0e12c2e6e9e61c980c20ea9e90c192a2556", + "VALIDATION.json": "681325a61e11ea228729debb9c8629814df441a60fe4faa3735554dba29a7b1f", + "historical/work/p518-next/bit/weighted/rank9/parabolic/INDEPENDENT.json": "b80c137491fe45c4e7c8a28987581047fb05ca139685d14c094e43f23b6fc1e7", + "historical/work/p518-next/bit/weighted/rank9/parabolic/PROOF.md": "c4f7fbe4851d52e4f7daf6389e2b2b0ad758bb9a9cf5be60a70df3234b2ecb67", + "historical/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py": "8c41c12c044ab5bc515a1f6f1dc44dce6550ff3051f77262942873f5e5bb5f45", + "historical/work/p518-next/bit/weighted/rank9/quick.json": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "replay.log": "b2e9cbe5c104028fd32942d900443b30debcf7dbd7bd8b7e05ea14400429b376", + "replayed-receipt.json": "b80c137491fe45c4e7c8a28987581047fb05ca139685d14c094e43f23b6fc1e7", + "verify.py": "27a3c0e109b38f7b8da957e211cd15565973c738aa123033befca27d5b0b6ec0" +} diff --git a/research/e8-hyperplane-minrank/review/STATUS.json b/research/e8-hyperplane-minrank/review/STATUS.json new file mode 100644 index 0000000000..535af7a7eb --- /dev/null +++ b/research/e8-hyperplane-minrank/review/STATUS.json @@ -0,0 +1,17 @@ +{ + "status": "PASS_ALTERNATIVE_PROOF_ANNEX", + "reviewer": "separate OpenAI Codex agent /root/e8_cost_review", + "utc": "2026-10-23T04:23:10.015614+00:00", + "new_floor": false, + "new_kappa": false, + "comparative_speedup_claim": false, + "prior_theorem_pr": 3045, + "prior_theorem_head": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "package_files": 10, + "package_bytes_unchanged": true, + "schur_states_checked": 62208, + "negative_controls": 3, + "unresolved_material_findings": [], + "review_sha256": "eae1854fcb5cf1217a17c953f4063b48378259c85a0b458350f464fe48d6a4cb", + "reviewed_manifest_sha256": "8d3344224a34c56aff908d52528503b9d4b0b3bae5fbe3d34092292604e4ade2" +} diff --git a/research/e8-hyperplane-minrank/review/historical-replay-command.json b/research/e8-hyperplane-minrank/review/historical-replay-command.json new file mode 100644 index 0000000000..df5ddef0e1 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/historical-replay-command.json @@ -0,0 +1,13 @@ +{ + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-parabolic-review-doja88yy/parabolic/independent_check.py" + ], + "logical_source_command": "python3 -E -B parabolic/independent_check.py in a temporary copy with ../quick.json", + "exit_code": 0, + "elapsed_seconds": 0.18563413619995117, + "complete_receipt_match": true, + "parallelism": "One process" +} diff --git a/research/e8-hyperplane-minrank/review/historical-replay.stderr.txt b/research/e8-hyperplane-minrank/review/historical-replay.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/e8-hyperplane-minrank/review/historical-replay.stdout.txt b/research/e8-hyperplane-minrank/review/historical-replay.stdout.txt new file mode 100644 index 0000000000..4f2cf060cb --- /dev/null +++ b/research/e8-hyperplane-minrank/review/historical-replay.stdout.txt @@ -0,0 +1,66 @@ +{ + "status": "PASS", + "input_sha256": "621cc49f29bf382cbca0cc49f3a9091173de683c52357efdc264f55c1c105256", + "integer_root_count": 240, + "simple_basis_and_reflection_checks": true, + "all_eight_certificates_checked": true, + "parabolics": [ + { + "node": 1, + "type": "D7", + "root_lines_inside": 42, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 2, + "type": "A7", + "root_lines_inside": 28, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 3, + "type": "A6+A1", + "root_lines_inside": 22, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 4, + "type": "A4+A2+A1", + "root_lines_inside": 14, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 5, + "type": "A4+A3", + "root_lines_inside": 16, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 6, + "type": "D5+A2", + "root_lines_inside": 23, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 7, + "type": "E6+A1", + "root_lines_inside": 37, + "certificate_lines": 13, + "incident_zero_constraints": 8 + }, + { + "node": 8, + "type": "E7", + "root_lines_inside": 63, + "certificate_lines": 13, + "incident_zero_constraints": 8 + } + ], + "scope": "Finite certificates and simple roots. The universal theorem also uses the Weyl chamber and fitting rank arguments in PROOF.md." +} diff --git a/research/e8-hyperplane-minrank/review/independent-controls.json b/research/e8-hyperplane-minrank/review/independent-controls.json new file mode 100644 index 0000000000..3168485728 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/independent-controls.json @@ -0,0 +1,214 @@ +{ + "status": "PASS", + "package": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank", + "binary_field": "F2", + "signed_roots": 240, + "certificates": [ + { + "deleted_node": 1, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 2, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 3, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 4, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 5, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 6, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 7, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + }, + { + "deleted_node": 8, + "rank_eight_assignments_checked": 7776, + "rank_eight_assignments_feasible": 0, + "four_witness_positive_control": [ + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ] + } + ], + "total_schur_assignments": 62208, + "negative_controls": [ + { + "name": "changed_certificate_hash", + "exit_code": 1, + "expected_stderr": "Source hash:", + "actual_stderr": "Source hash: historical/work/p518-next/bit/weighted/rank9/quick.json\n" + }, + { + "name": "missing_node_with_updated_hash", + "exit_code": 1, + "expected_stderr": "The certificate must cover each deleted node once.", + "actual_stderr": "The certificate must cover each deleted node once.\n" + }, + { + "name": "optimized_mode", + "exit_code": 1, + "expected_stderr": "Run this verifier without -O.", + "actual_stderr": "Run this verifier without -O. Historical sources use assert.\n" + } + ], + "scope": "Exact finite certificate and Schur checks. Universal coverage also uses the written Weyl-chamber proof." +} diff --git a/research/e8-hyperplane-minrank/review/independent_controls.py b/research/e8-hyperplane-minrank/review/independent_controls.py new file mode 100644 index 0000000000..82c09243a1 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/independent_controls.py @@ -0,0 +1,137 @@ +"""Check the small E8 certificates and their binary Schur constraints.""" + +import argparse +import hashlib +import itertools +import json +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +parser = argparse.ArgumentParser() +parser.add_argument("package", type=Path) +parser.add_argument("--output", type=Path) +args = parser.parse_args() +package = args.package.resolve() +relative = "historical/work/p518-next/bit/weighted/rank9/quick.json" +data = json.loads((package / relative).read_text()) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def dot(left, right): + return sum(x * y for x, y in zip(left, right)) + + +roots = set() +for i, j in itertools.combinations(range(8), 2): + for first, second in itertools.product((-2, 2), repeat=2): + row = [0] * 8 + row[i], row[j] = first, second + roots.add(tuple(row)) +roots.update(row for row in itertools.product((-1, 1), repeat=8) + if row.count(-1) % 2 == 0) +require(len(roots) == 240, "Expected all signed E8 roots") +require(sorted(item["node"] for item in data["parabolics"]) == list(range(1, 9)), + "Each node must occur once") +pairs = [tuple(pair) for pair in data["pairs"]] +require(len(pairs) == len(set(pairs)) == 5, "Expected five distinct pairs") +require(all(len(pair) == len(set(pair)) == 2 for pair in pairs), "Pairs need two endpoints") +require(len(set().union(*map(set, pairs))) == 4, "Expected four endpoints") +require(all(0 <= x < 8 for pair in pairs for x in pair), "Anchor index out of range") + + +def states(pair): + masks = [sum((1 << anchor) for k, anchor in enumerate(pair) if (choice >> k) & 1) + for choice in range(4)] + return [(c, b) for c in masks for b in masks if (c & b).bit_count() % 2 == 1] + + +reports = [] +for item in data["parabolics"]: + normal = item["normal"] + rows = [tuple(row) for row in item["certificate"]] + require(len(rows) == 13 and all(row in roots for row in rows), "Invalid certificate root") + require(len({min(row, tuple(-x for x in row)) for row in rows}) == 13, + "Repeated root line") + require(all(dot(normal, row) != 0 for row in rows), "Certificate must avoid the hyperplane") + require([j + 1 for j, root in enumerate(data["simple_roots"]) if dot(normal, root)] + == [item["node"]], "Normal has the wrong deleted node") + require(sum(dot(normal, row) == 0 for row in roots) == 2 * item["roots_in_hyperplane"], + "Wrong hyperplane count") + anchors, witnesses = rows[:8], rows[8:] + require(all(dot(a, b) for a, b in itertools.combinations(anchors, 2)), "Anchor block is not I8") + for pair, witness in zip(pairs, witnesses): + require(tuple(j for j, anchor in enumerate(anchors) if dot(anchor, witness) == 0) == pair, + "Wrong witness support") + forced = [(e, f) for e in range(5) for f in range(5) + if e != f and dot(witnesses[e], witnesses[f]) != 0] + choices = [states(pair) for pair in pairs] + require(all(len(choice) == 6 for choice in choices), "Expected six binary diagonal states") + feasible = 0 + tested = 0 + for candidate in itertools.product(*choices): + tested += 1 + if all((candidate[e][0] & candidate[f][1]).bit_count() % 2 == 0 for e, f in forced): + feasible += 1 + require(tested == 7776 and feasible == 0, "A rank-eight fitting Schur completion survived") + # Four witnesses have a rank-eight completion. This checks the five-edge boundary. + four = next((candidate for candidate in itertools.product(*choices[:4]) + if all((candidate[e][0] & candidate[f][1]).bit_count() % 2 == 0 + for e, f in forced if e < 4 and f < 4)), None) + require(four is not None, "Four-witness positive control failed") + reports.append({"deleted_node": item["node"], "rank_eight_assignments_checked": tested, + "rank_eight_assignments_feasible": feasible, + "four_witness_positive_control": [[c, b] for c, b in four]}) + +controls = [] +with tempfile.TemporaryDirectory(prefix="e8-parabolic-controls-") as temporary: + temporary = Path(temporary) + copied = temporary / "package" + shutil.copytree(package, copied) + + def reject(name, expected, optimized=False): + command = [sys.executable, "-E", "-B"] + if optimized: + command.append("-O") + command += [str(copied / "verify.py"), "--build", str(temporary / name)] + completed = subprocess.run(command, capture_output=True, text=True, timeout=60) + require(completed.returncode != 0 and expected in completed.stderr, + "Wrong rejection point: " + name) + controls.append({"name": name, "exit_code": completed.returncode, + "expected_stderr": expected, "actual_stderr": completed.stderr}) + + raw = (copied / relative).read_bytes() + (copied / relative).write_bytes(raw + b" ") + reject("changed_certificate_hash", "Source hash:") + (copied / relative).write_bytes(raw) + + mutated = json.loads(raw) + mutated["parabolics"][1] = mutated["parabolics"][0] + (copied / relative).write_text(json.dumps(mutated) + "\n") + manifest_path = copied / "SOURCE-MANIFEST.json" + manifest_raw = manifest_path.read_bytes() + manifest = json.loads(manifest_raw) + for item in manifest["files"]: + if item["package"] == relative: + item["sha256"] = hashlib.sha256((copied / relative).read_bytes()).hexdigest() + manifest_path.write_text(json.dumps(manifest) + "\n") + reject("missing_node_with_updated_hash", "The certificate must cover each deleted node once.") + (copied / relative).write_bytes(raw) + manifest_path.write_bytes(manifest_raw) + + reject("optimized_mode", "Run this verifier without -O.", optimized=True) + +result = {"status": "PASS", "package": str(package), "binary_field": "F2", + "signed_roots": len(roots), "certificates": reports, + "total_schur_assignments": sum(row["rank_eight_assignments_checked"] for row in reports), + "negative_controls": controls, + "scope": "Exact finite certificate and Schur checks. Universal coverage also uses the written Weyl-chamber proof."} +if args.output: + args.output.write_text(json.dumps(result, indent=2) + "\n") +print("PASS_E8_PARABOLIC_INDEPENDENT certificates=8 schur_assignments=62208 rejected=3") diff --git a/research/e8-hyperplane-minrank/review/wrapper-command.json b/research/e8-hyperplane-minrank/review/wrapper-command.json new file mode 100644 index 0000000000..b2ea772b63 --- /dev/null +++ b/research/e8-hyperplane-minrank/review/wrapper-command.json @@ -0,0 +1,16 @@ +{ + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/e8-hyperplane-minrank/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/e8-parabolic/fresh-wrapper-replay" + ], + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "exit_code": 0, + "python": "3.14.7", + "elapsed_seconds": 0.18544316291809082, + "all_package_bytes_unchanged": true, + "parallelism": "One sequential standard-library process and child." +} diff --git a/research/e8-hyperplane-minrank/review/wrapper.stderr.txt b/research/e8-hyperplane-minrank/review/wrapper.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/e8-hyperplane-minrank/review/wrapper.stdout.txt b/research/e8-hyperplane-minrank/review/wrapper.stdout.txt new file mode 100644 index 0000000000..54e0fa0c4a --- /dev/null +++ b/research/e8-hyperplane-minrank/review/wrapper.stdout.txt @@ -0,0 +1,2 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/e8-parabolic/fresh-wrapper-replay/work/p518-next/bit/weighted/rank9/parabolic/independent_check.py +PASS_E8_HYPERPLANE_MINRANK 240 8 13 diff --git a/research/e8-hyperplane-minrank/verify.py b/research/e8-hyperplane-minrank/verify.py new file mode 100644 index 0000000000..ff4805b7ea --- /dev/null +++ b/research/e8-hyperplane-minrank/verify.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +"""Check the saved eight parabolic certificates without discovery search.""" +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +ROOT = Path(__file__).resolve().parent +parser = argparse.ArgumentParser() +parser.add_argument("--build", type=Path, required=True) +args = parser.parse_args() +build = args.build.resolve() +if build.exists(): + raise SystemExit("The build directory exists.") +for item in json.loads((ROOT / "SOURCE-MANIFEST.json").read_text())["files"]: + if hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() != item["sha256"]: + raise SystemExit("Source hash: " + item["package"]) +certificate = json.loads((ROOT / "historical/work/p518-next/bit/weighted/rank9/quick.json").read_text()) +if sorted(item["node"] for item in certificate["parabolics"]) != list(range(1, 9)): + raise SystemExit("The certificate must cover each deleted node once.") +shutil.copytree(ROOT / "historical", build) +relative = Path("work/p518-next/bit/weighted/rank9/parabolic") +command = [sys.executable, "-E", "-B", str(build / relative / "independent_check.py")] +print("Run:", " ".join(command), flush=True) +with (build / "check.stdout.log").open("w") as out, (build / "check.stderr.log").open("w") as err: + subprocess.run(command, check=True, stdout=out, stderr=err) +result = json.loads((build / relative / "INDEPENDENT.json").read_text()) +expected = json.loads((ROOT / "historical" / relative / "INDEPENDENT.json").read_text()) +if result != expected: + raise SystemExit("The finite result differs from the saved receipt.") +(build / "receipt.json").write_text(json.dumps(result, indent=2) + "\n") +print("PASS_E8_HYPERPLANE_MINRANK 240 8 13") diff --git a/research/e8-small-redundancy/COORDINATE-PROOF.md b/research/e8-small-redundancy/COORDINATE-PROOF.md new file mode 100644 index 0000000000..97561ad628 --- /dev/null +++ b/research/e8-small-redundancy/COORDINATE-PROOF.md @@ -0,0 +1,113 @@ +# Rigidity of nine E8 totals at coordinate hyperplanes + +## Scope + +Repository inspected: `wht-power-saving-lean` at commit `9c94857bbaee886f8649edee0bc2d3c738f9555e`. + +This result uses the canonical rank-eight E8 coefficient space. It does not cover all fitting matrices or all sets of nine frames. It does not prove a global copy-cost floor of 72. + +Let the 120 source indices consist of triples and pairs from nine points. For a triple T, set a(T) to its incidence vector, t(T)=1, and p(T)=a(T) over F_2. For a pair i w dot a(T) : w in Q^9, sum_i w_i=0 }. + +This is the space spanned by the eight totals a_k-a_8. It has dimension eight. The pair values w_i-w_j show that the map from zero-sum w to a coefficient function is injective. + +Let F_i={p : p_i=0}. Suppose there are nine rational totals g_i such that: + +1. g_i(T)=0 whenever p_i(T)=1; +2. the span of the nine g_i contains E. + +Then, for each i, there is a nonzero rational c_i with + +g_i(T)=c_i(a_i(T)-t(T)). + +Each g_i has 64 nonzero coefficients. Their binary source labels span F_i. Thus no one of these nine totals can use a proper subspace of F_i, even if all nine coefficient vectors can change. The result excludes all single-total frame reductions within the nine coordinate hyperplanes. + +## Link to the scatter matrix + +The canonical fitting matrix is + +B(S,T)=(a(S) dot a(T)-t(S)t(T))/2. + +Set q(S)=a(S)-(t(S)/3)1. Since sum_i a_i(S)=3t(S), the coordinates of q(S) sum to zero. Direct expansion gives B(S,T)=q(S) dot q(T)/2. In particular, every row of B belongs to E. + +For the pair source S=P_i8, where 0<=i<8, the row of B is (a_i-a_8)/2. These eight rows form a basis of E. Hence rowspace(B)=E exactly. Any factorization B=RG through nine retained totals has E contained in rowspace(G), as required by the proposition. + +The nine canonical totals g_i=a_i-t do reconstruct B. Set + +R_i(S)=(a_i(S)-t(S)/3)/2. + +Their sum over i is zero. Therefore + +sum_i R_i(S)g_i(T) +=sum_i R_i(S)a_i(T) +=(a(S) dot a(T)-t(S)t(T))/2 +=B(S,T). + +Thus the proposition concerns the coefficient space of the actual canonical scatter. It does not assume that the nine totals are the eight published totals plus one unused register. + +The support condition is necessary for phase A in the current gcert format. Each source X_T starts at the binary line spanned by p(T). Each helper starts with zero coefficients of the X sources; its arbitrary initial dirt is a separate input. Frame moves only enlarge the frame, and every scalar gate uses one common frame for all of its ports. Induction over these moves and gates shows that a nonzero X_T coefficient in a register at frame U requires p(T) in U. Cancellation does not break this invariant. The checks for these rules are in the pinned [tools/gx/gx.py](https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/tools/gx/gx.py): the source starts, nested frame moves, common gate frame, and scalar replay. Therefore, if each of the nine retained frames is constrained to lie inside its coordinate hyperplane, the result forces that frame to equal the entire hyperplane. The sum of their dimensions, and hence their copy cost in this format, is 9*8=72. This does not exclude a design with other frames or a mechanism with frame moves that are not nested. + +## Full-support lemma + +Every nonzero element of E has source labels that span F_2^9. + +To prove this, suppose w dot a(T) is zero whenever z dot p(T)=1, for a nonzero binary z. Let A be the support of z, and let s=|A|. + +If s is even, the pair indices with one point in A and one outside A have z dot p=1. Their equations give w_i=w_j across the cut. Both parts are nonempty, so all nine coordinates of w are equal. Their sum is zero, so w=0. + +If s is odd, the pair equations give one constant a on A and one constant b on its complement. If s=1, a triple with one point in A gives a+2b=0. The zero-sum equation gives a+8b=0. Thus a=b=0. If 3<=s<=7, a triple contained in A gives 3a=0. The zero-sum equation then gives b=0. If s=9, all coordinates are equal and their sum is zero. Thus w=0 in every case. + +Every proper binary subspace is contained in a hyperplane. The claim follows. + +The repository already states the resulting floor of 72 for eight totals at the canonical scatter. This lemma is an independent proof of that existing claim. + +## Proof of the nine-total result + +Let T be the span of the nine totals. Each total has support in a proper binary subspace. By the full-support lemma, E has no nonzero element with such support. + +Since E is contained in T, T has dimension at least eight. If its dimension were eight, every g_i would be in E and hence zero. Therefore T has dimension nine. The nine totals are independent, and each has a nonzero image in the one-dimensional quotient T/E. + +Scale each total by a nonzero rational number so that all nine images in T/E agree. These scale changes preserve support. Now g_i-g_j belongs to E for every i,j. + +Write g_i-g_j=w dot a, where the coordinates of w sum to zero. For each k other than i,j, the triple {i,j,k} lies outside both F_i and F_j. Both totals are zero there, so + +w_i+w_j+w_k=0. + +The seven coordinates outside {i,j} have one common value c. The equation above gives w_i+w_j=-c. The zero-sum condition then gives 6c=0. Thus c=0, and w_i=-w_j. It follows that + +g_i-g_j=alpha_ij(a_i-a_j). + +For three distinct indices, use (g_i-g_j)+(g_j-g_k)=g_i-g_k. The coefficient map on zero-sum vectors is injective. Comparison of its i,j,k coordinates shows that alpha_ij=alpha_jk=alpha_ik. Hence there is one common alpha and + +g_i=g_0+alpha(a_i-a_0). + +For each source index, choose an i with p_i=1. Such an index exists because every port is nonzero. At that source, a_i=t: both are one for a triple that contains i, and both are zero for a pair whose binary label contains i. Since g_i=0 there, g_0=alpha(a_0-t). Therefore + +g_i=alpha(a_i-t). + +The common alpha is nonzero, because the totals span a space that contains E. Undo the individual scale changes to obtain the stated result. + +For each i, a_i-t is nonzero on the 56 triples that omit i and on the eight pairs that contain i. Its support therefore has size 64. The weight-three labels on the other eight points span all of F_i: their pairwise differences span the even-weight subspace, and one triple supplies an odd-weight vector. Thus the binary support rank is eight. + +## Independent finite checks + +The `coordinate/coordinate_totals_rigidity.py` file uses only the standard library. It imports no repository module. It checks the 120 certificate ports against the definitions above. + +It also checks the exact linear equations for nine supported totals. After quotient normalization, write g_i=f+e_i, with e_i in E, and choose e_0=0. There are 64 rational variables for e_1,...,e_8. If a port lies outside both F_i and F_j, impose (e_i-e_j)(T)=0. + +For the nine coordinate hyperplanes, the equation matrix has rational rank 63. Its kernel has dimension one and gives the totals t-a_i. An independent modular elimination gives rank 63 over both F_101 and F_103. + +To reduce F_0 by one dimension, add a normal b with b_0=0. A nondegenerate reduced frame requires b to have odd weight. The stabilizer that permutes the other eight coordinates gives four cases, with weights 1, 3, 5, and 7. Their orbit sizes are 8, 56, 56, and 8, for a total of 128. Each case has rational rank 64 and zero kernel. Both modular checks also give rank 64. This covers all 128 nondegenerate seven-dimensional subframes of F_0. Permutation of the nine points gives the same result for every other F_i. + +The analytic result is stronger: it excludes every proper subspace of every F_i, including degenerate subspaces, and permits changes to all nine coefficient vectors. + +Run from the repository root: + +``` +python3 -B research/e8-small-redundancy/verify.py +``` + +The checker also verifies all 14,400 entries of the nine-total scatter identity with exact rational arithmetic. The saved JSON records the exact ranks, the modular ranks, the kernel, the support counts, the orbit sizes, and the certificate hash. These checks do not run Lean or verify the complete E8 circuit. diff --git a/research/e8-small-redundancy/ELEVEN-PROOF.md b/research/e8-small-redundancy/ELEVEN-PROOF.md new file mode 100644 index 0000000000..2a0005908b --- /dev/null +++ b/research/e8-small-redundancy/ELEVEN-PROOF.md @@ -0,0 +1,260 @@ +# Eleven scalar centres cannot reduce E8 bit copy rank below 72 + +This proof uses the definitions and the ten-centre theorem in `TEN-PROOF.md`. +Write `rho(w)` for the rational rank of the root support of a binary word. +Write `e_S` for the indicator of a set of root lines, and write `k_q` for +row `q` of the binary corrector matrix `K`. Root vectors have squared length +4. A sign change in a root vector does not change any binary word. + +## Statement and scope + +Every binary factorization `K=A B^T` with at most eleven scalar terms has +source-reader pairing-rank sum at least 72. The drop-pricing theorem of +PR #446 therefore excludes a copy-rank improvement in this retained-total +model with at most eleven centres. + +The result does not bound twelve or more centres, or a different model of +totals and gates. It does not give a positive improvement to the bit bound. + +The factor-rank cases other than `(9,11)` and `(11,9)` were proved in +`TEN-PROOF.md`. It remains to prove the following statement: + +> If a binary space `U` of dimension eleven contains `C`, then every basis +> of `U` has rational support-rank sum at least 72. + +For factor ranks `(9,11)`, a zero column on the rank-nine side removes a +term and reduces to the ten-centre theorem. Otherwise its columns are +nonzero words in `C`, so their support spaces are all eight-dimensional. +Each pairing rank is then the support rank of the opposite column. Those +eleven columns form a basis of their column space `U`, which contains `C`. +The transpose case is identical. + +The quotient `U/C` has dimension two. It has three nonzero cosets. All +nonzero vectors in `C` have support rank eight. + +## Finite facts and their verification + +The following exact facts concern only the 120 pinned E8 root lines. + +1. `C` has dimension nine. Its word-weight distribution is + `0:1, 56:255, 64:255, 120:1`. Every nonzero word has support rank eight. +2. The eight Weyl classes of root hyperplanes, the sets `D_H`, and their + outside support spans have the descriptions in `TEN-PROOF.md`. In particular, + a non-E7 hyperplane has at most 42 root lines. +3. In an E7 hyperplane `H=n^perp`, the outside weights of the 512 words of + `C` have distribution + `0:1, 1:1, 24:63, 25:63, 28:128, 29:128, 32:63, 33:63, 56:1, 57:1`. + The unique outside-weight-one word is `k_n`, with support `H union {n}`. +4. The seven maximal proper E7 root-flat types have 16, 21, 13, 10, 36, 21, + and 30 root lines. Each complement spans all seven dimensions. Thus a + proper root span in E7 has at most 36 lines, and the complement of every + proper root span has rank seven. +5. In E7, the nonperpendicular neighbors of any root line span seven + dimensions. Every pair of distinct root lines has 16 common + nonperpendicular neighbors, distinct from the pair. +6. Distinct root lines have inner product 0 or plus or minus 2. All root + vectors have squared length 4. + +`parabolic_check.py` verifies items 1, 2, 5, and 6, including reflection +closure. `e7_complements.py` verifies item 4 by all seven simple-root +deletions of E7. `eleven_facts.py` verifies item 3. The same Weyl-chamber +argument used for E8 in `TEN-PROOF.md` shows that these seven E7 deletions cover +all maximal proper E7 root flats. Thus the checks cover every proper root +span, not sampled flats. All rank decisions below full rank use exact +rational arithmetic. + +## Every coset has a star description + +For every coset `V` other than `C` that has a word of rank at most seven, +there is a centre `a` in `V` and a set `Q` of root lines with these properties: + +- The lines in `Q` belong to the support of `a`. +- Each `q in Q` is perpendicular to every other line in the support of `a`. + In particular, the lines in `Q` are pairwise perpendicular. +- The low-rank words in `V` are exactly the satellites `a+k_q`, for `q in Q`, + together with `a` itself if `rho(a)<=7`. +- Every satellite has rank seven. The centre can have rank eight; in that + case the centre is not a low-rank word. + +To prove this, choose a low-rank word `v` and a root hyperplane `H` that +contains its support. If `H` is not E7, the proof in `TEN-PROOF.md` gives precisely +this description with centre `a=v` and with the isolated support roots as +`Q`. + +Now let `H=n^perp` be E7 and put `t=k_n`. Define `A` and `B` as in `TEN-PROOF.md`: +`A` consists of the isolated roots in the support of `v`, and `B` consists of +the isolated roots in its complement within `H`. The only possible low-rank +words are `v`, `v+t`, `v+k_q` for `q in A`, and `v+t+k_q` for `q in B`. +The last two groups have rank seven. The sets `A` and `B` cannot both be +nonempty, by the common-neighbor fact. + +Put `d=rho(v)` and let `e` be the rank of its complementary support in `H`. +If `d<=6`, the E7 complement fact gives `e=7`, and the neighbor-rank fact +gives `B` empty. If `e<=6`, then `d=7` and `A` is empty. +If `B` is nonempty or `e<=6`, take `a=v+t` and `Q=B union {n}`. The support +of `a` is `{n}` together with the complementary support in `H`, so every +line in `Q` is isolated there. Its rank is `1+e`. Its satellite at `n` is +`v`; its other satellites are the listed words indexed by `B`. +Otherwise `B` is empty and `e=7`; take `a=v` and `Q=A`. +This proves the description in every case. + +## Small changes to a codeword + +Suppose `0!=c in C`, `|S|<=11`, and `rho(c+e_S)<=7`. Then for some root `n`, + +\[ + c=k_n,\qquad n\in S,\qquad S\setminus\{n\}\subset n^\perp, + \qquad \rho(c+e_S)=7. \tag{2} +\] + +Choose a root hyperplane `H` containing the support of `c+e_S`. If `H` is +not E7, the support of `c` outside `H` has at least `56-42=14` lines. Those +lines would all have to belong to `S`, a contradiction. Thus `H=n^perp` +is E7. The outside-weight distribution shows that `c=k_n`: every other +nonzero word has at least 24 outside lines. Since `k_n` has just the root +`n` outside `H`, cancellation requires `S outside H={n}`. Inside `H`, the +remaining support is `H\S`, with at least 53 lines. It cannot lie in a +proper E7 root span, which has at most 36 lines. Its rank is therefore seven. + +## The basis defect + +Let a basis of `U` be given. The defect of a vector is `8-rho(w)`. Suppose, +for contradiction, that its total defect `D` is at least 17. The coset bound +in `TEN-PROOF.md` gives at most eight defects in any one nonzero quotient coset. +Hence all three cosets contain selected low-rank basis vectors. + +Give these cosets star descriptions with centres `a_1,a_2,a_3`. Put +`d_i=rho(a_i)`. Let `Q_i` be the roots of the satellites selected in the +basis, and let `n_i=|Q_i|`. Say that a centre is selected when the centre +itself belongs to the basis. We may count a selected rank-eight centre as +well; it contributes zero defect. There are no other positive-defect words. +Thus, if `delta` centres are selected and `n=n_1+n_2+n_3`, + +\[ + \delta+n\leq11,\qquad + D=\sum_{i:\ a_i\text{ selected}}(8-d_i)+n. \tag{3} +\] + +Remove the selected isolated roots from each centre: + +\[ + u_i=a_i+e_{Q_i},\qquad \rho(u_i)=d_i-n_i. +\] + +The rank equality follows because each removed root is perpendicular to +all remaining support roots. The quotient images of the three centres sum +to zero, so `c=a_1+a_2+a_3` belongs to `C`. Set +`S=Q_1 triangle Q_2 triangle Q_3`, the symmetric difference. Then + +\[ + u_1+u_2+u_3=c+e_S,\qquad |S|\leq n\leq11, +\] + +and + +\[ + \sum_i\rho(u_i) + =24-D-\sum_{i:\ a_i\text{ not selected}}(8-d_i) + \leq7. \tag{4} +\] + +Two distinct roots cannot belong to both `Q_i` and `Q_j`: the four +corresponding satellites would sum to zero. Therefore + +\[ + |Q_i\cap Q_j|\leq1\quad(i\ne j). \tag{5} +\] + +### Independent centres: `c!=0` + +Equation (2) applies. Write `c=k_n` as there. The sum `u_1+u_2+u_3` has +support rank seven, while (4) bounds the sum of their support ranks by +seven. Its support spans `n^perp`. Consequently each `u_i` is supported in +`n^perp`, `D=17`, and every unselected centre has rank eight. + +Consider an unselected centre `a_i`. Its remaining support and its selected +isolated roots give an orthogonal direct sum of all eight dimensions. +Since `u_i` is supported in `n^perp`, the root `n` belongs to the span of +`Q_i`. If its line is not itself in `Q_i`, expand it in these pairwise +perpendicular roots. Every nonzero coefficient is plus or minus one half: +this follows from the root inner products and squared lengths. Its squared +length then forces exactly four nonzero coefficients. Thus four roots of +`Q_i` are not perpendicular to `n`. + +By (2), every one of these four roots must occur an even number of times +among the three sets `Q_i`; otherwise it would belong to `S` outside +`n^perp`. Each therefore belongs to one of the other two sets. This +contradicts (5). We conclude that `n` belongs to `Q_i` for every unselected +centre. + +If no centre is unselected, all three centres belong to the basis and +`k_n=c` is their sum. The root `n` belongs to at least one `Q_i`, so its +satellite and that centre give a basis dependence. + +If one centre is unselected, its selected satellite at `n`, together with +the other two selected centres, sums to `c+k_n=0`. + +If two centres are unselected, their two sets `Q_i` both contain `n`. +Since `n in S`, the third set must also contain `n`. The three selected +satellites at `n` sum to `c+3k_n=0` over the binary field. + +If all three centres are unselected, the same three-satellite dependence +holds. Each case contradicts basis independence. + +### Dependent centres: `c=0` + +Any two centres are independent, because their quotient images are distinct +nonzero elements of `U/C`. We use the following elementary real-linear +bound. If `a_3=a_1+a_2`, every root in their supports occurs in exactly two +of the supports. Lift such a root `q` to + +\[ + (q,0),\quad(0,q),\quad\text{or }(q,q) +\] + +according as it belongs only to `a_1`, only to `a_2`, or to both. These +vectors lie in the direct sum of the two rational support spaces. +For a root isolated in `a_1`, the dual vector `(q,0)` pairs to zero with +every other lifted root. For a root isolated in `a_2`, use `(0,q)`; for a +root isolated in `a_3`, use `(q,-q)`. Each self-pairing is nonzero. +Hence all distinct selected satellite roots have independent lifts. If +there are `N` such roots, then + +\[ + N\leq\min(d_1+d_2,d_1+d_3,d_2+d_3). \tag{6} +\] + +At most two centres can be selected. +If none is selected, `D=n<=11`, a contradiction. +If two are selected, all three centres lie in their span. A repeated root +among the selected satellites would give a dependence with these centres. +Thus `n=N`. If the selected centres are `a_1,a_2`, equations (3) and (6) +give `D<=16-d_1-d_2+d_1+d_2=16`. + +It remains to consider exactly one selected centre, say `a_1`. A root +cannot occur in both `Q_2` and `Q_3`: those two satellites would sum to +`a_1`. Each of the other pairwise intersections has at most one root by +(5). They cannot both be nonempty: the four satellites from these two +intersections, together with `a_1`, would sum to zero. Therefore there is +at most one repeated root in the full list of selected satellites. Using +(6), + +\[ + n\leq N+1\leq d_1+\min(d_2,d_3)+1, + \qquad D\leq8+\min(d_2,d_3)+1\leq17. +\] + +Equality `D=17` requires `d_2=d_3=8`, exactly one repeated root, and +`N=d_1+8`. The selected-vector count is then at least +`1+n=d_1+10`, so `d_1<=1`. A centre in a nonzero coset is nonzero, hence +`d_1=1`. Only one root line lies in a one-dimensional support, so +`a_1=e_r` for one root `r`. The repeated root must be `r`, since the only +allowed repetition involves `Q_1`. + +But `a_2+a_3=e_r`. If `r` is isolated in the rank-eight centre `a_2`, +removing it gives `a_3` rank seven, a contradiction. The same argument +applies with `a_2,a_3` exchanged. Thus equality 17 is impossible here too. + +Both centre cases give `D<=16`. Every basis therefore has rank sum at least +`11*8-16=72`. This closes factor ranks `(9,11)` and `(11,9)`, and completes +the eleven-centre obstruction. diff --git a/research/e8-small-redundancy/ORIGINS.json b/research/e8-small-redundancy/ORIGINS.json new file mode 100644 index 0000000000..83be700198 --- /dev/null +++ b/research/e8-small-redundancy/ORIGINS.json @@ -0,0 +1,215 @@ +[ + { + "file": "COORDINATE-PROOF.md", + "original_workspace_path": "outputs/e8-additional-results/coordinate-totals/coordinate_totals_rigidity.md", + "original_sha256": "83a3a696713601ce7215e66bf8764790e44f033ba712070337e4029fde88096a", + "adaptations": [ + { + "before": "The adjacent Python file", + "after": "The `coordinate/coordinate_totals_rigidity.py` file" + }, + { + "before": "Run from the additional-results directory:", + "after": "Run from the repository root:" + }, + { + "before": "python3 -I -B coordinate-totals/coordinate_totals_rigidity.py ../e8-coupled-retiming/research/e8-coupled-retiming/data/original.json.gz", + "after": "python3 -B research/e8-small-redundancy/verify.py" + }, + "Add a commit-pinned link to the frame-rule implementation." + ] + }, + { + "file": "reviews/COORDINATE-HISTORICAL.md", + "original_workspace_path": "outputs/e8-additional-results/coordinate-totals/independent-review.md", + "original_sha256": "35a6e6df37db38509ea20d6e59c16d1cc64c035f7e316784e17d715b6fea0bcd", + "adaptations": [] + }, + { + "file": "coordinate/coordinate_totals_rigidity.py", + "original_workspace_path": "outputs/e8-additional-results/coordinate-totals/coordinate_totals_rigidity.py", + "original_sha256": "eb8b43b61ae39167a2a50b328133cc855ae8af93b8b0dc662271805da9bae87f", + "adaptations": [] + }, + { + "file": "coordinate/rigidity_review_72vars.py", + "original_workspace_path": "outputs/e8-additional-results/coordinate-totals/rigidity_review_72vars.py", + "original_sha256": "f8ff34c96a1caea91a587fbc489e0d5900ac49a85e2f227b3d6e6d43180b3d8c", + "adaptations": [] + }, + { + "file": "coordinate/coordinate_totals_rigidity.json", + "original_workspace_path": "outputs/e8-additional-results/coordinate-totals/coordinate_totals_rigidity.json", + "original_sha256": "3c6451e577588bad30d69cdf1d03e8188233def2b2298ce019785189f255e6c7", + "adaptations": [] + }, + { + "file": "TEN-PROOF.md", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/PROOF.md", + "original_sha256": "dda431ee2836e5140a0d73786f624a713329cacaa4c39bfbcc01026697b86233", + "adaptations": [ + { + "before": "Thus only factor ranks `(9,11)` and `(11,9)` remain open for eleven centres.\nThis corollary does not close those cases or any case with more centres.", + "after": "This proof leaves factor ranks `(9,11)` and `(11,9)` for eleven centres.\nThe companion `ELEVEN-PROOF.md` closes those two cases. Neither proof covers\nmore than eleven centres." + }, + { + "before": "python3 work/next-track/bit/ten-centres/theory/parabolic_check.py", + "after": "python3 -B research/e8-small-redundancy/verify.py" + }, + { + "before": "The script uses only the Python standard library and the pinned compressed\nword. It also checks", + "after": "The replay uses only the Python standard library and the pinned compressed\nword. Its binary checks include" + }, + { + "before": "Its\noutput is `parabolic-results.json`. The input is read without modification.", + "after": "The\nreceipts are checked in a temporary copy. Inputs remain unchanged." + }, + "Define the algebraic pairing-rank objective and separate it from the inherited physical drop-price interpretation." + ] + }, + { + "file": "ELEVEN-PROOF.md", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/ELEVEN-PROOF.md", + "original_sha256": "2bc8e531ce6d3d683f760a4208e9be2a061fe15b54bca0034de59c292c17f65e", + "adaptations": [ + { + "before": "`PROOF.md`", + "after": "`TEN-PROOF.md`" + } + ] + }, + { + "file": "reviews/BINARY-HISTORICAL.md", + "original_workspace_path": "work/next-track/bit/ten-centres/INDEPENDENT-AUDIT.md", + "original_sha256": "3670d15cbc464b2f5992a3608c3b0a6228b07b709b6138f68cbea6a360ea5cee", + "adaptations": [] + }, + { + "file": "binary/parabolic_check.py", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/parabolic_check.py", + "original_sha256": "2b5844504f2681cd8783196b4506edbb24bedb1dd6593d6d07eb18448657dfff", + "adaptations": [ + { + "before": "BASE = Path(__file__).resolve().parents[2]\nSOURCE = BASE / 'pinned462/research/r740-hosted-rank151-mixed/data/word.json.gz'", + "after": "SOURCE = Path(__file__).resolve().parents[1] / 'inputs/bit-word.json.gz'" + } + ] + }, + { + "file": "binary/e7_complements.py", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/e7_complements.py", + "original_sha256": "f6dda16ec0f9dd8a349b633a59c3dc167fa408e48d89592e595ad55f60805626", + "adaptations": [] + }, + { + "file": "binary/eleven_facts.py", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/eleven_facts.py", + "original_sha256": "65c02ecc24c26f1a39f5081f5b1d0b94ad24578a1ae008d59d486dafeb4a36e0", + "adaptations": [] + }, + { + "file": "binary/parabolic-results.json", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/parabolic-results.json", + "original_sha256": "5d86cc60d2447de2569d68f646c391c5358255c9c301f4d9f5007303abfed8ed", + "adaptations": [] + }, + { + "file": "binary/e7-complements.json", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/e7-complements.json", + "original_sha256": "5a404b3158f7ee8fb4d5dd418b4dd5da6973934873f7c6ad6d5679f0c046f5e3", + "adaptations": [] + }, + { + "file": "binary/eleven-facts.json", + "original_workspace_path": "work/next-track/bit/ten-centres/theory/eleven-facts.json", + "original_sha256": "c739190ae3ed151720a166b18cd50e5812c31a86351d3e5cf0a74d6c7f18adaf", + "adaptations": [] + }, + { + "file": "binary/standard_e8.py", + "original_workspace_path": "work/next-track/bit/ten-centres/flat_bound.py", + "original_sha256": "0601a8aacf636ff8c9375dd2a94122751bbe1424991ac2b59b724ebe9096e5b2", + "adaptations": [ + "Retain only the common geometry before out=[]; omit the exploratory loop." + ] + }, + { + "file": "binary/independent_structure.py", + "original_workspace_path": "work/next-track/bit/ten-centres/independent_structure.py", + "original_sha256": "9218b5a0519f72a7b27b5c94791157eb943c4fbc207ecbf10bcf59f008198db3", + "adaptations": [ + { + "before": "exec(open(__file__.replace('independent_structure.py','flat_bound.py')).read().split('out=[]')[0])", + "after": "from standard_e8 import *" + } + ] + }, + { + "file": "binary/independent_eleven_facts.py", + "original_workspace_path": "work/next-track/bit/ten-centres/independent_eleven_facts.py", + "original_sha256": "c3584b1b459b43b365c71b14660f6fa694d7d2ac4f64227069bc4da999abb522", + "adaptations": [ + { + "before": "exec(open(__file__.replace('independent_eleven_facts.py','flat_bound.py')).read().split('out=[]')[0])", + "after": "from standard_e8 import *" + } + ] + }, + { + "file": "binary/independent_coordinate_map.py", + "original_workspace_path": "work/next-track/bit/ten-centres/independent_coordinate_map.py", + "original_sha256": "38c4b0ad5e4f599ba7fa50519bd74a088bb6eb6d4dd9f93258de3aa0ea54a7cf", + "adaptations": [ + { + "before": "exec(open(__file__.replace('independent_coordinate_map.py','flat_bound.py')).read().split('out=[]')[0])", + "after": "from standard_e8 import *" + }, + { + "before": "p=Path(__file__).resolve().parents[1]/'pinned462/research/r740-hosted-rank151-mixed/data/word.json.gz'", + "after": "p=Path(__file__).resolve().parents[1]/'inputs/bit-word.json.gz'" + } + ] + }, + { + "file": "binary/independent-structure-result.json", + "original_workspace_path": "work/next-track/bit/ten-centres/independent-structure-result.json", + "original_sha256": "c07c8e7439c45f7069a62f87174db558176c61cc48b8de8c04c2786f90a34054", + "adaptations": [] + }, + { + "file": "binary/independent-eleven-facts.json", + "original_workspace_path": "work/next-track/bit/ten-centres/independent-eleven-facts.json", + "original_sha256": "7365b244ae3448a063dea4ee7070c716c1b73a9fff9f85d260d8dd57a68ca638", + "adaptations": [] + }, + { + "file": "binary/independent-coordinate-map.json", + "original_workspace_path": "work/next-track/bit/ten-centres/independent-coordinate-map.json", + "original_sha256": "96e699d144215dd561ca1fd7e3174cb914460738cea83eb8742bae0365a0ef95", + "adaptations": [] + }, + { + "file": "inputs/bit-word.json.gz", + "original_workspace_path": "work/next-track/bit/pinned462/research/r740-hosted-rank151-mixed/data/word.json.gz", + "original_sha256": "4e0e45082510c35af95e27e79ffda272b61ae97121685d90037df7901faf8617", + "adaptations": [] + }, + { + "file": "inputs/BIT-NOTICE.md", + "original_workspace_path": "work/next-track/bit/pinned462/research/r740-hosted-rank151-mixed/NOTICE.md", + "original_sha256": "8162cded5bbb985cbea704fd2e05e35133ae5efea3a0294b7aad8eae2a340f8b", + "adaptations": [] + }, + { + "file": "inputs/complex-word.json.gz", + "original_workspace_path": "outputs/e8-coupled-retiming/research/e8-coupled-retiming/data/original.json.gz", + "original_sha256": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "adaptations": [] + }, + { + "file": "inputs/COMPLEX-NOTICE.md", + "original_workspace_path": "outputs/e8-coupled-retiming/research/e8-coupled-retiming/NOTICE.md", + "original_sha256": "d90e498b08ebc83951ae44f5b3c507eac314ee03e7cab53df675e7a86da9046b", + "adaptations": [] + } +] diff --git a/research/e8-small-redundancy/README.md b/research/e8-small-redundancy/README.md new file mode 100644 index 0000000000..bdf0715d2b --- /dev/null +++ b/research/e8-small-redundancy/README.md @@ -0,0 +1,100 @@ +# Two low-redundancy obstructions for fixed E8 matrices + +This package gives two scoped structural results. It does not give a new +supplier, a paid implementation, or a change to the complete kappa bound. +The two results use different scalar fields and different support prices. +Their bounds must not be substituted for each other. + +| Fixed matrix | Scalar field | Covered class | Result | +| --- | --- | --- | --- | +| Canonical rank-eight E8 Gram matrix | Q | Nine totals, each supported in its assigned binary coordinate hyperplane | Each total is a nonzero multiple of `a_i-t`. Its support spans the full dimension-eight hyperplane. | +| `K(q,r)=1+(q dot r)/2 mod 2`, for the 120 norm-four root lines | F2 | Any outer-product factorization with at most eleven scalar terms | The sum of rational source-reader pairing ranks is at least 72. | + +The first result classifies the coefficients, not just their cost. It allows +all nine totals to change at once. The second result permits arbitrary binary +factors outside the rank-nine code. It closes the ten- and eleven-term cases +left open by the minimal nine-term copy-rank argument. + +The proofs are in `COORDINATE-PROOF.md`, `TEN-PROOF.md`, and `ELEVEN-PROOF.md`. +The latter two use finite root-system facts checked in two coordinate models. +The written Weyl-chamber reduction is part of the proof. The scripts check +its finite premises; they are not a formal proof of that reduction. + +## Cost interpretation and limits + +The binary theorem is an algebraic pairing-rank floor. Its interpretation +as a physical drop-cost floor assumes the separate scalar copy-tree model +of DreamingOfClouds' [PR #446](https://github.com/CrocSwap/integer-mult-bounds/pull/446), +[Theorem C](https://github.com/CrocSwap/integer-mult-bounds/blob/309482849b6ddf34db998f53612d34c19f6e3233/research/format-obstructions/PROOF.md). +The algebraic theorem does not depend on that physical interpretation. +Dynamic mixing during delivery, shared charges, twelve or more terms, changed +fitting matrices, and punctured root sets remain outside the result. +Source access, legal frames, restoration, hosting, and recursive children +are not priced here. No complete kappa improvement follows. + +The rational coordinate theorem assumes the fixed canonical scatter and the +nine specified hyperplanes. Its coefficient classification is more specific +than a general copy-cost floor. It does not classify other frame choices. + +## Reproduce + +Use Python 3.10 or later and the standard library. From the repository root: + +```sh +python3 -B research/e8-small-redundancy/verify.py +``` + +The final line is: + +```text +PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa +``` + +The replay checks source hashes before execution. It uses a temporary copy +for the historical scripts that write receipts. It compares every saved +mathematical receipt with the new result. It checks all 511 nonzero binary +codewords, eight E8 root-hyperplane types, seven E7 maximal proper-flat +types, the outside-word histogram, and the exact map between the two root +models. The coordinate check proves the required finite ranks over Q and +checks all 14,400 scatter entries. A separate 72-variable calculation gives +ranks 71,72,72,72,72 over F107. + +The written proofs and these finite premises had separate AI agent reviews. +The retained historical reviews identify their scope. This is not independent +human review, a Lean theorem, a complete circuit replay, or hosted CI success. + +## Sources, overlap, and credit + +The publication base is `cef4b52f2a59009865bf8eabde1be3f159063703`. +`SOURCES.json` records public pins. `ORIGINS.json` records the original local +sources and the limited path/module changes made for portable replay. +The two input notices retain their source credits. Jacob Sussman supplied +the rational E8 circuit and certificate. The bit word is from Rohan Arun's +historical PR462 head; its notices credit the underlying E8 and supplier +work. This package uses only its root lines, not its claimed supplier bound. + +The depth-one binary nine-term floor is prior work, including Joel Pulikkan / +GamingPuzzled's [PR #620](https://github.com/CrocSwap/integer-mult-bounds/pull/620) +and the later [tensor floor](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/tensor-e8-copy-floor/README.md). +Ross Richardson's [R429 reader floors](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/r429-binary-reader-floors/README.md) +cover a different, punctured 111-line matrix. conorholds' [one-coset theorem](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/e8-one-coset-deficiency/README.md) +uses a rational/odd-characteristic rank-eight code and binary support prices. +It does not imply the binary-factor theorem here. Its stronger general +rational floor does subsume our old nine-small-total numerical obstruction; +that superseded experiment is omitted from this package. The coefficient +classification for nine specified coordinate hyperplanes is retained. + +Ali Romman directed this work. OpenAI Codex and separate research agents +provided substantial assistance with the proofs, code, audit, and packaging. +New work is under Apache-2.0. Attribution does not imply review or endorsement. + +## Open next questions + +Can a binary factorization with twelve terms reduce the same pairing-rank +sum? The first step is to classify its factor ranks and the resulting +three-dimensional quotient of the rank-nine code. The two-dimensional +quotient proof here does not cover that case. + +Can a useful shared delivery operation escape the separate copy-tree price? +The first step is to give one complete legal map with arbitrary dirt restored. +Support overlap alone does not provide that map or its recursive cost. diff --git a/research/e8-small-redundancy/SOURCE-HASHES.json b/research/e8-small-redundancy/SOURCE-HASHES.json new file mode 100644 index 0000000000..408728c704 --- /dev/null +++ b/research/e8-small-redundancy/SOURCE-HASHES.json @@ -0,0 +1,31 @@ +{ + "COORDINATE-PROOF.md": "74cc1758d25ad4a598082a9da3df3835701c603accae1c9be92a83bfb849d8c3", + "ELEVEN-PROOF.md": "afa044fce728f8b5a17217a26cd51aa5261afde3065f0cd4e8c8b5c9121de302", + "ORIGINS.json": "3f0ba7f39f83c646c7f51db3fe3da942a874d05d94974ac6d9c19ff7bdce7d9f", + "README.md": "ba9d62c9fcf2a9913edd7c8985d4a6aae365e4c4762551ba9d84cd06dc8c0818", + "SOURCES.json": "e7a8618da02faccd9ceca1b57bfacf0ce1503877cd0d828c360f53771aab1ee2", + "TEN-PROOF.md": "f3bab259f11cc14415b0d1a242e76ca8371094d7814686e7251ff5b1579fb572", + "binary/e7-complements.json": "5a404b3158f7ee8fb4d5dd418b4dd5da6973934873f7c6ad6d5679f0c046f5e3", + "binary/e7_complements.py": "f6dda16ec0f9dd8a349b633a59c3dc167fa408e48d89592e595ad55f60805626", + "binary/eleven-facts.json": "c739190ae3ed151720a166b18cd50e5812c31a86351d3e5cf0a74d6c7f18adaf", + "binary/eleven_facts.py": "65c02ecc24c26f1a39f5081f5b1d0b94ad24578a1ae008d59d486dafeb4a36e0", + "binary/independent-coordinate-map.json": "96e699d144215dd561ca1fd7e3174cb914460738cea83eb8742bae0365a0ef95", + "binary/independent-eleven-facts.json": "7365b244ae3448a063dea4ee7070c716c1b73a9fff9f85d260d8dd57a68ca638", + "binary/independent-structure-result.json": "c07c8e7439c45f7069a62f87174db558176c61cc48b8de8c04c2786f90a34054", + "binary/independent_coordinate_map.py": "c945811051664249d618d7f2784727adb218f4dfdab996b28948f5a624df1785", + "binary/independent_eleven_facts.py": "e5fa81f7652c21a9554fbf007624c85d982bc5d6d677203762018974cb2cf574", + "binary/independent_structure.py": "cf882c06e74f2badbca7c1efa1a584e92c63e1e6d1700d94a9283bfd676db746", + "binary/parabolic-results.json": "5d86cc60d2447de2569d68f646c391c5358255c9c301f4d9f5007303abfed8ed", + "binary/parabolic_check.py": "d687708f7d18fc070240f6e78f2e04a5fc6686bce8cc592f7fdb31fd53a77ce4", + "binary/standard_e8.py": "e357acc9af0ec645953aab0a3930735a8d368bf3ef3c5f329e0f67f1d7db3bcb", + "coordinate/coordinate_totals_rigidity.json": "3c6451e577588bad30d69cdf1d03e8188233def2b2298ce019785189f255e6c7", + "coordinate/coordinate_totals_rigidity.py": "eb8b43b61ae39167a2a50b328133cc855ae8af93b8b0dc662271805da9bae87f", + "coordinate/rigidity_review_72vars.py": "f8ff34c96a1caea91a587fbc489e0d5900ac49a85e2f227b3d6e6d43180b3d8c", + "inputs/BIT-NOTICE.md": "8162cded5bbb985cbea704fd2e05e35133ae5efea3a0294b7aad8eae2a340f8b", + "inputs/COMPLEX-NOTICE.md": "d90e498b08ebc83951ae44f5b3c507eac314ee03e7cab53df675e7a86da9046b", + "inputs/bit-word.json.gz": "4e0e45082510c35af95e27e79ffda272b61ae97121685d90037df7901faf8617", + "inputs/complex-word.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "reviews/BINARY-HISTORICAL.md": "3670d15cbc464b2f5992a3608c3b0a6228b07b709b6138f68cbea6a360ea5cee", + "reviews/COORDINATE-HISTORICAL.md": "35a6e6df37db38509ea20d6e59c16d1cc64c035f7e316784e17d715b6fea0bcd", + "verify.py": "ec852870bd2884d8b83322e7015acfd5a8c70466ba2789219aa63cda9b89aa9b" +} diff --git a/research/e8-small-redundancy/SOURCES.json b/research/e8-small-redundancy/SOURCES.json new file mode 100644 index 0000000000..c322cb6889 --- /dev/null +++ b/research/e8-small-redundancy/SOURCES.json @@ -0,0 +1,28 @@ +{ + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "inputs": [ + { + "path": "inputs/bit-word.json.gz", + "sha256": "4e0e45082510c35af95e27e79ffda272b61ae97121685d90037df7901faf8617", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/c4df4fdbf411f047ff7d63c73c432e828e94d924/research/r740-hosted-rank151-mixed/data/word.json.gz", + "role": "Only the 120 norm-four root lines are used.", + "live_byte_check": "GitHub contents API matched all 55386 bytes during packaging." + }, + { + "path": "inputs/complex-word.json.gz", + "sha256": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/tools/certificate/gcert1-e8-r783.json.gz", + "role": "The 120 binary source labels bind the rational coefficient model." + } + ], + "physical_model": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/309482849b6ddf34db998f53612d34c19f6e3233/research/format-obstructions/PROOF.md", + "theorem": "C", + "status": "Explicit inherited written theorem; not re-proved by this package." + }, + "new_kappa": false, + "coordinate_frame_model": { + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/tools/gx/gx.py", + "role": "Written bridge for the source-frame invariant and copy-charge interpretation; not executed by this package." + } +} diff --git a/research/e8-small-redundancy/TEN-PROOF.md b/research/e8-small-redundancy/TEN-PROOF.md new file mode 100644 index 0000000000..d61866bfe7 --- /dev/null +++ b/research/e8-small-redundancy/TEN-PROOF.md @@ -0,0 +1,229 @@ +# A ten-centre copy-rank obstruction for the E8 bit matrix + +Let `Q` be the 120 E8 root lines in the pinned bit word. Use the listed vectors, +which have squared length 4. Put + +\[ + K_{qr}=1+\frac{q\cdot r}{2}\pmod 2, + \qquad C=\operatorname{rowspan}_{\mathbb F_2}K. +\] + +For a binary vector `w` on the 120 lines, let `rho(w)` be the rational dimension +of its support. Thus `rho(0)=0`. The exact check gives `dim C=9` and +`rho(c)=8` for every nonzero `c` in `C`. + +## Result + +Every coset `v+C` other than `C` satisfies + +\[ + \sum_{w\in v+C}(8-\rho(w))\leq 8. \tag{1} +\] + +Consequently, if ten independent vectors span a space that contains `C`, their +support ranks sum to at least 72. More generally, for each binary factorization +`K=A B^T`, define the pairing-rank objective by + +`sum_j rank_Q ((q dot r)_(q in supp(a_j), r in supp(b_j)))`. + +Here `a_j` and `b_j` are the columns of A and B. Every ten-term factorization +has objective at least 72. This is an algebraic statement. Its interpretation +as a physical drop-cost floor uses the separate scalar copy-tree model and +Theorem C of PR #446. A different delivery model need not have that price. + +## Finite geometric facts + +A support of rank at most seven lies in a rank-seven flat of the E8 root +matroid. Every such flat is Weyl-conjugate to the roots generated by seven +simple roots. To see this, move a normal vector into a closed dominant Weyl +chamber. A positive root is perpendicular to the normal precisely when its +simple-root expansion uses only simple roots perpendicular to the normal. +A root flat of rank seven therefore omits exactly one simple root. + +The check derives a simple system from the 240 signed roots, then checks all +eight deletions. This covers every rational root hyperplane, not only eight +sampled hyperplanes. Weyl transformations preserve `C` and support rank, since +they preserve the Gram matrix modulo 2, including a change in root signs. + +For a root hyperplane `H`, set + +\[ + D_H=\{c\in C:\rho(\operatorname{supp}(c)\setminus H)\leq7\}. +\] + +Write `k_q` for row `q` of `K`. The following facts are checked by exact linear +algebra in `parabolic_check.py`. + +1. The eight hyperplanes have 14, 16, 22, 23, 28, 37, 42, and 63 root lines. +2. If `H` is not the 63-line E7 hyperplane, then + `D_H = {0} union {k_q: q in H}`. For each `q in H`, the support of `k_q` + outside `H` spans exactly `q^perp`, of dimension seven. +3. If `H=n^perp` is the E7 hyperplane, put `t=k_n`. Its support is exactly + `H union {n}`. In this case + `D_H = {0,t} union {k_q,k_q+t: q in H}`. The outside support of either + `k_q` or `k_q+t` spans exactly `q^perp`. +4. Within E7, the lines other than `q` that are not perpendicular to `q` span + all seven dimensions. Each pair of distinct lines has exactly 16 common + nonperpendicular neighbors, distinct from the pair. + +There are only 512 words in `C`, so the check of each `D_H` is exhaustive. +Ranks below eight are checked over the rational numbers. A rank-eight result +modulo 101 certifies rational rank eight. This use of reduction modulo a prime +can only certify full rank; it never treats a smaller modular rank as a +rational rank. + +## Proof of the coset bound + +If the coset has no word of rank at most seven, (1) is immediate. Otherwise +choose such a word `v`, and choose a root hyperplane `H` that contains its +support. Let `d=rho(v)`. + +If `w=v+c` has rank at most seven, its support outside `H` equals that of `c`. +Thus `c` belongs to `D_H`. + +First suppose `H` is not E7. Every low-rank word other than `v` has the form +`v+k_q`, for `q in H`. Its outside support already spans `q^perp`, so the +whole support must lie in `q^perp`. This requires: + +- `v(q)=1`; +- `v(r)=0` for every other `r in H` that is not perpendicular to `q`. + +Conversely, these conditions suffice. Each such word has rank seven. +The admissible lines `q` are pairwise perpendicular and belong to the support +of `v`. There are at most `d` of them. The sum in (1) is therefore at most +`(8-d)+d=8`. + +Now let `H=n^perp` be E7. Put + +\[ + d=\rho(\operatorname{supp}v),\qquad + e=\rho(H\setminus\operatorname{supp}v). +\] + +Then `d,e<=7` and `d+e>=7`. The word `v+t` has rank `1+e`, since its support +is `{n}` together with the complement of the support of `v` in `H`. +All other possible low-rank words have rank exactly seven. They are: + +- `v+k_q`, where `q` is in the support of `v` and is perpendicular to every + other line in that support; call these indices `A`. +- `v+t+k_q`, where `q` is in the complementary support and is perpendicular + to every other line in that complementary support; call these indices `B`. + +Thus `|A|<=d` and `|B|<=e`. If `d<=6`, then `B` is empty: a member of `B` +would put all its nonperpendicular neighbors into the support of `v`, but +those neighbors have rank seven. Similarly, `e<=6` implies that `A` is empty. +Also, `A` and `B` cannot both be nonempty. A common nonperpendicular neighbor +of one member of each would have to lie both in the support and its complement. + +These statements prove (1) in all four cases: + +| Case | Sum of all rank defects is at most | +|---|---| +| `d<=6`, `e<=6` | `(8-d)+(7-e)<=8`, since `d+e>=7` | +| `d<=6`, `e=7` | `(8-d)+|A|<=8` | +| `d=7`, `e<=6` | `1+(7-e)+|B|<=8` | +| `d=e=7` | `1+max(|A|,|B|)<=8` | + +The words in each list are distinct. For E7, this also follows directly from +the checked description of `D_H`. + +## From coset rank defects to ten centres + +Let `K=A B^T`, where `A` and `B` have ten columns. Each column records the +binary source or reader support of one scalar retained total. Omit any term +with a zero column. If at most nine terms remain, the binary rank-nine bound +forces exactly nine terms. Both factors then have column space `C`, so each +source and reader support spans all eight rational dimensions. The total +pairing rank is 72. + +Otherwise both factors have ten nonzero columns. Their ranks are at least +nine. They cannot both have rank ten: an injective `A` and a surjective `B^T` +would give rank ten for their product. Hence one factor, say `A`, has rank +nine. Its column space equals the column space of `K`, namely `C`, because +`K` is symmetric. Every column of `A` has rational support rank eight. +The rational source-reader pairing for a column therefore has rank exactly +the rational support rank of the corresponding column of `B`. + +If `B` has binary rank nine, each nonzero column belongs to `C` and the sum is +80. If `B` has binary rank ten, its column space is a ten-dimensional space +`U` that contains `C`. Thus `U=C union (v+C)` for one `v` outside `C`. +The columns of `B` are independent, so they are distinct. All nonzero columns +in `C` have zero rank defect. Equation (1) bounds the sum of the defects of +the remaining columns by eight. Their rank sum is at least `80-8=72`. + +This excludes every ten-centre copy-rank total below 72, including 71. + +## Eleven centres when both factors have binary rank ten + +Suppose `K=A B^T` has eleven columns in each factor, and both factors have +binary rank ten. Then the total source-reader pairing rank is at least 72. + +First, a zero column lets us omit its term and use the ten-centre result. +If two columns of `A` are equal, merge the terms + +\[ + a b_1^T+a b_2^T=a(b_1+b_2)^T. +\] + +Let `U` be the rational support span of `a`, and let `V_1,V_2` be those of +`b_1,b_2`. The support span of `b_1+b_2` is contained in `V_1+V_2`. The rank +of its pairing with `U` is therefore at most + +\[ + \operatorname{rank}(U,V_1+V_2) + \leq \operatorname{rank}(U,V_1)+\operatorname{rank}(U,V_2). +\] + +Thus merging does not increase cost. The resulting factorization has at most +ten terms, so the ten-centre result applies. The same argument applies to +repeated columns of `B`. + +It remains to consider nonzero, distinct columns in each factor. Each column +space has dimension ten and contains `C`. Equation (1) therefore gives + +\[ + \sum_{j=1}^{11}(8-\rho(a_j))\leq8,\qquad + \sum_{j=1}^{11}(8-\rho(b_j))\leq8. +\] + +For subspaces `U,V` of the nondegenerate eight-dimensional label space, + +\[ + \operatorname{rank}(U,V) + =\dim U-\dim(U\cap V^\perp) + \geq \dim U+\dim V-8. +\] + +Sum this inequality over the eleven terms. The total pairing rank is at least + +\[ + (88-8)+(88-8)-88=72. +\] + +An eleven-term factorization of rank-nine `K` must have factor ranks +`(9,9)`, `(9,10)`, `(10,9)`, `(9,11)`, `(11,9)`, or `(10,10)`, since their +rank sum cannot exceed 20. The cases in which one rank is nine and the other +is at most ten also have cost at least 72. To see this, first remove zero +terms or merge repeated columns as above. Otherwise, the rank-nine factor +has nonzero columns in `C`, so its rational support spans have dimension +eight. The pairing cost is the sum of support ranks on the other side. If +that side has binary rank nine, all eleven support ranks are eight. If it +has binary rank ten, the columns are distinct and (1) bounds their total +defect by eight, so their support ranks sum to at least 80. + +This proof leaves factor ranks `(9,11)` and `(11,9)` for eleven centres. +The companion `ELEVEN-PROOF.md` closes those two cases. Neither proof covers +more than eleven centres. + +## Replay + +From the workspace root, run: + +```sh +python3 -B research/e8-small-redundancy/verify.py +``` + +The replay uses only the Python standard library and the pinned compressed +word. Its binary checks include reflection closure of all 240 signed roots, the binary +code dimension, and the full support rank of every nonzero codeword. The +receipts are checked in a temporary copy. Inputs remain unchanged. diff --git a/research/e8-small-redundancy/binary/e7-complements.json b/research/e8-small-redundancy/binary/e7-complements.json new file mode 100644 index 0000000000..34fa635ba9 --- /dev/null +++ b/research/e8-small-redundancy/binary/e7-complements.json @@ -0,0 +1,44 @@ +[ + { + "delete": 0, + "inside_count": 16, + "complement_count": 47, + "complement_rank": 7 + }, + { + "delete": 1, + "inside_count": 21, + "complement_count": 42, + "complement_rank": 7 + }, + { + "delete": 2, + "inside_count": 13, + "complement_count": 50, + "complement_rank": 7 + }, + { + "delete": 3, + "inside_count": 10, + "complement_count": 53, + "complement_rank": 7 + }, + { + "delete": 4, + "inside_count": 36, + "complement_count": 27, + "complement_rank": 7 + }, + { + "delete": 5, + "inside_count": 21, + "complement_count": 42, + "complement_rank": 7 + }, + { + "delete": 6, + "inside_count": 30, + "complement_count": 33, + "complement_rank": 7 + } +] diff --git a/research/e8-small-redundancy/binary/e7_complements.py b/research/e8-small-redundancy/binary/e7_complements.py new file mode 100644 index 0000000000..36486535e4 --- /dev/null +++ b/research/e8-small-redundancy/binary/e7_complements.py @@ -0,0 +1,22 @@ +"""Check the complements of maximal proper E7 root flats.""" +import json +import runpy +from pathlib import Path + +namespace = runpy.run_path(str(Path(__file__).with_name('parabolic_check.py'))) +roots = namespace['ROOTS'] +simple = namespace['simple'] +rankq = namespace['rankq'] +result = namespace['result'] +e7 = next(item for item in result['hyperplanes'] if item['inside_count'] == 63) +system = simple[:e7['delete']] + simple[e7['delete']+1:] +output = [] +for delete in range(7): + basis = system[:delete] + system[delete+1:] + inside = [q for q in e7['inside'] if rankq(basis + [roots[q]]) == 6] + complement = [q for q in e7['inside'] if q not in inside] + r = rankq([roots[q] for q in complement]) + assert r == 7 + output.append({'delete':delete,'inside_count':len(inside),'complement_count':len(complement),'complement_rank':r}) +print(json.dumps(output,indent=2)) +Path(__file__).with_name('e7-complements.json').write_text(json.dumps(output,indent=2)+'\n') diff --git a/research/e8-small-redundancy/binary/eleven-facts.json b/research/e8-small-redundancy/binary/eleven-facts.json new file mode 100644 index 0000000000..6f828d926a --- /dev/null +++ b/research/e8-small-redundancy/binary/eleven-facts.json @@ -0,0 +1,16 @@ +{ + "e7_outside_weight_histogram": { + "0": 1, + "1": 1, + "33": 63, + "32": 63, + "25": 63, + "24": 63, + "56": 1, + "57": 1, + "29": 128, + "28": 128 + }, + "unique_nonzero_small_word": "K_normal", + "threshold": 13 +} diff --git a/research/e8-small-redundancy/binary/eleven_facts.py b/research/e8-small-redundancy/binary/eleven_facts.py new file mode 100644 index 0000000000..109ede4485 --- /dev/null +++ b/research/e8-small-redundancy/binary/eleven_facts.py @@ -0,0 +1,22 @@ +"""Check the outside weights used in the eleven-centre proof.""" +import json +import runpy +from pathlib import Path + +ns = runpy.run_path(str(Path(__file__).with_name('parabolic_check.py'))) +code = ns['code'] +roots = ns['ROOTS'] +e7 = next(h for h in ns['result']['hyperplanes'] if h['inside_count'] == 63) +mask = sum(1 << j for j in range(120) if j not in e7['inside']) +histogram = {} +small = [] +for c in code: + weight = (c & mask).bit_count() + histogram[weight] = histogram.get(weight, 0) + 1 + if c and weight <= 13: + small.append(c) +assert len(small) == 1 and small[0] == ns['root_code'][e7['normal']] +assert histogram == {0:1,1:1,24:63,25:63,28:128,29:128,32:63,33:63,56:1,57:1} +output = {'e7_outside_weight_histogram':histogram,'unique_nonzero_small_word':'K_normal','threshold':13} +print(json.dumps(output,indent=2)) +Path(__file__).with_name('eleven-facts.json').write_text(json.dumps(output,indent=2)+'\n') diff --git a/research/e8-small-redundancy/binary/independent-coordinate-map.json b/research/e8-small-redundancy/binary/independent-coordinate-map.json new file mode 100644 index 0000000000..0a94f589cb --- /dev/null +++ b/research/e8-small-redundancy/binary/independent-coordinate-map.json @@ -0,0 +1,97 @@ +{ + "verified": true, + "root_lines": 120, + "rational_similarity_factor": "1/2", + "simple_root_permutation": [ + 6, + 1, + 0, + 3, + 2, + 5, + 4, + 7 + ], + "matrix": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1/2", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1/2", + "1/2" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "-1/2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "1/2", + "0", + "0" + ], + [ + "0", + "0", + "1/2", + "-1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "1/2", + "-1/2", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ] +} diff --git a/research/e8-small-redundancy/binary/independent-eleven-facts.json b/research/e8-small-redundancy/binary/independent-eleven-facts.json new file mode 100644 index 0000000000..abb3054aef --- /dev/null +++ b/research/e8-small-redundancy/binary/independent-eleven-facts.json @@ -0,0 +1,58 @@ +{ + "verified": true, + "root_squared_norm": 8, + "distinct_root_products": [ + -4, + 0, + 4 + ], + "outside_weight_histogram": { + "0": 1, + "1": 1, + "24": 63, + "25": 63, + "28": 128, + "29": 128, + "32": 63, + "33": 63, + "56": 1, + "57": 1 + }, + "e7_rank_six_flats": [ + { + "deleted": 0, + "inside_count": 30, + "complement_rank": 7 + }, + { + "deleted": 1, + "inside_count": 21, + "complement_rank": 7 + }, + { + "deleted": 2, + "inside_count": 16, + "complement_rank": 7 + }, + { + "deleted": 3, + "inside_count": 10, + "complement_rank": 7 + }, + { + "deleted": 4, + "inside_count": 13, + "complement_rank": 7 + }, + { + "deleted": 5, + "inside_count": 21, + "complement_rank": 7 + }, + { + "deleted": 6, + "inside_count": 36, + "complement_rank": 7 + } + ] +} diff --git a/research/e8-small-redundancy/binary/independent-structure-result.json b/research/e8-small-redundancy/binary/independent-structure-result.json new file mode 100644 index 0000000000..a6407a6d96 --- /dev/null +++ b/research/e8-small-redundancy/binary/independent-structure-result.json @@ -0,0 +1,55 @@ +{ + "verified": true, + "hyperplanes": [ + { + "deleted": 0, + "flat_roots": 42, + "good_count": 43, + "common_neighbor_counts": [] + }, + { + "deleted": 1, + "flat_roots": 28, + "good_count": 29, + "common_neighbor_counts": [] + }, + { + "deleted": 2, + "flat_roots": 22, + "good_count": 23, + "common_neighbor_counts": [] + }, + { + "deleted": 3, + "flat_roots": 14, + "good_count": 15, + "common_neighbor_counts": [] + }, + { + "deleted": 4, + "flat_roots": 16, + "good_count": 17, + "common_neighbor_counts": [] + }, + { + "deleted": 5, + "flat_roots": 23, + "good_count": 24, + "common_neighbor_counts": [] + }, + { + "deleted": 6, + "flat_roots": 37, + "good_count": 38, + "common_neighbor_counts": [] + }, + { + "deleted": 7, + "flat_roots": 63, + "good_count": 128, + "common_neighbor_counts": [ + 16 + ] + } + ] +} diff --git a/research/e8-small-redundancy/binary/independent_coordinate_map.py b/research/e8-small-redundancy/binary/independent_coordinate_map.py new file mode 100644 index 0000000000..2b699e0a13 --- /dev/null +++ b/research/e8-small-redundancy/binary/independent_coordinate_map.py @@ -0,0 +1,27 @@ +"""Check an exact similarity between both coordinate systems.""" +from standard_e8 import * +from itertools import permutations +import gzip +p=Path(__file__).resolve().parents[1]/'inputs/bit-word.json.gz' +ham=json.load(gzip.open(p,'rt'))['lines'] +def normalize(r): + r=tuple(r) + return tuple(-x for x in r) if next(x for x in r if x)<0 else r +positive={normalize(r) for r in ham} +simple=sorted(q for q in positive if not any(tuple(x-y for x,y in zip(q,r)) in positive for r in positive)) +assert len(simple)==8 +perm=next(p for p in permutations(range(8)) if all(dot(a[i],a[j])==2*dot(simple[p[i]],simple[p[j]]) for i in range(8) for j in range(8))) +rows=[[Fraction(x) for x in a[i]+simple[perm[i]]] for i in range(8)] +for j in range(8): + k=next(k for k in range(j,8) if rows[k][j]);rows[k],rows[j]=rows[j],rows[k] + z=rows[j][j];rows[j]=[x/z for x in rows[j]] + for k in range(8): + if k!=j: + z=rows[k][j];rows[k]=[x-z*y for x,y in zip(rows[k],rows[j])] +T=[r[8:] for r in rows] +image={normalize([sum(Fraction(r[j])*T[j][k] for j in range(8)) for k in range(8)]) for r in roots} +assert image==positive +assert all(dot(T[i],T[j])==Fraction(int(i==j),2) for i in range(8) for j in range(8)) +out={'verified':True,'root_lines':120,'rational_similarity_factor':'1/2','simple_root_permutation':perm,'matrix':[[str(x) for x in r] for r in T]} +Path(__file__).with_name('independent-coordinate-map.json').write_text(json.dumps(out,indent=2)+'\n') +print('Verified all 120 root lines under an exact rational similarity.') diff --git a/research/e8-small-redundancy/binary/independent_eleven_facts.py b/research/e8-small-redundancy/binary/independent_eleven_facts.py new file mode 100644 index 0000000000..74f84dafbd --- /dev/null +++ b/research/e8-small-redundancy/binary/independent_eleven_facts.py @@ -0,0 +1,21 @@ +"""Check the extra finite facts for the eleven-centre proof.""" +from standard_e8 import * +from collections import Counter +assert all(dot(q,q)==8 for q in roots) +assert {dot(q,r) for i,q in enumerate(roots) for r in roots[i+1:]} <= {-4,0,4} +n=nullvec(a[:7]);H=[j for j,r in enumerate(roots) if not dot(r,n)] +O=[j for j in range(120) if j not in H] +nr=next(j for j in O if all(not dot(roots[j],roots[k]) for k in H)) +outside_hist=Counter(sum(c>>j&1 for j in O) for c in C) +assert outside_hist=={0:1,1:1,24:63,25:63,28:128,29:128,32:63,33:63,56:1,57:1} +assert {c for c in C if sum(c>>j&1 for j in O)<=13}=={0,K[nr]} +e7=[] +for d in range(7): + rows=[a[j] for j in range(7) if j!=d] + J=[j for j in H if rank_mod(rows+[roots[j]])==6] + assert rank_mod([roots[j] for j in H if j not in J])==7 + e7.append({'deleted':d,'inside_count':len(J),'complement_rank':7}) +assert max(x['inside_count'] for x in e7)==36 +out={'verified':True,'root_squared_norm':8,'distinct_root_products':[-4,0,4],'outside_weight_histogram':dict(sorted(outside_hist.items())),'e7_rank_six_flats':e7} +Path(__file__).with_name('independent-eleven-facts.json').write_text(json.dumps(out,indent=2)+'\n') +print(json.dumps(out,indent=2)) diff --git a/research/e8-small-redundancy/binary/independent_structure.py b/research/e8-small-redundancy/binary/independent_structure.py new file mode 100644 index 0000000000..95a8f2c9a9 --- /dev/null +++ b/research/e8-small-redundancy/binary/independent_structure.py @@ -0,0 +1,42 @@ +"""Verify the coset facts in independent standard E8 coordinates.""" +from standard_e8 import * + +def exact_rank(rows): + piv={} + for raw in rows: + z=list(map(Fraction,raw)) + for k,u in sorted(piv.items()): + f=z[k];z=[x-f*y for x,y in zip(z,u)] + if any(z): + k=next(k for k,x in enumerate(z) if x);f=z[k];piv[k]=[x/f for x in z] + return len(piv) + +def certified_rank(rows): + r=rank_mod(rows) + return 8 if r==8 else exact_rank(rows) + +def support(x):return [j for j in range(120) if x>>j&1] +assert all(certified_rank([roots[j] for j in support(c)])==8 for c in C[1:]) +report=[] +for d in range(8): + n=nullvec([r for j,r in enumerate(a) if j!=d]);H=[j for j,r in enumerate(roots) if not dot(r,n)]; O=[j for j in range(120) if j not in H] + good={c for c in C if certified_rank([roots[j] for j in O if c>>j&1])<8} + if len(H)==63: + nq=[j for j in O if all(dot(roots[j],roots[k])==0 for k in H)];assert len(nq)==1 + t=K[nq[0]];assert set(support(t))==set(H+nq) + expected={0,t}|{K[q]^s for q in H for s in (0,t)} + shifts=(0,t) + neigh={q:{r for r in H if q!=r and dot(roots[q],roots[r])!=0} for q in H} + assert all(exact_rank([roots[r] for r in neigh[q]])==7 for q in H) + common=[len(neigh[q]&neigh[r]) for q,r in combinations(H,2)] + assert min(common)>0 + else: + expected={0}|{K[q] for q in H};shifts=(0,);common=[] + assert good==expected + for q in H: + for s in shifts: + rs=[roots[j] for j in O if (K[q]^s)>>j&1] + assert exact_rank(rs)==7 and all(dot(roots[q],r)==0 for r in rs) + report.append({'deleted':d,'flat_roots':len(H),'good_count':len(good),'common_neighbor_counts':sorted(set(common))}) +print(json.dumps(report,indent=2)) +Path(__file__).with_name('independent-structure-result.json').write_text(json.dumps({'verified':True,'hyperplanes':report},indent=2)+'\n') diff --git a/research/e8-small-redundancy/binary/parabolic-results.json b/research/e8-small-redundancy/binary/parabolic-results.json new file mode 100644 index 0000000000..a124298e7b --- /dev/null +++ b/research/e8-small-redundancy/binary/parabolic-results.json @@ -0,0 +1,937 @@ +{ + "simple_roots": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + -1, + -1, + 0, + 0 + ], + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 1, + -1, + -1, + -1, + 0, + 0, + 0, + 0 + ] + ], + "gram": [ + [ + 2, + 0, + 0, + -1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 2, + 0, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + -1, + 0, + -1, + 0, + 0 + ], + [ + -1, + -1, + -1, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + -1, + 0, + -1 + ], + [ + 0, + 0, + -1, + 0, + -1, + 2, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 2 + ] + ], + "code_basis": [ + 5192296857325920255378465887420415, + 1324055981027703908952454057160540415, + 18446744073709551615, + 79228162495817593524129366015, + 1740220036293829470630638476564073, + 20203490921424933005051591393535, + 446521303967970293880411493359828053, + 268956873500151968514122094027721779, + 82753424537826645795398027293224975 + ], + "code_weight_histogram": { + "0": 1, + "64": 255, + "56": 255, + "120": 1 + }, + "hyperplanes": [ + { + "delete": 0, + "inside": [ + 3, + 5, + 6, + 15, + 29, + 31, + 38, + 39, + 57, + 59, + 61, + 63, + 70, + 71, + 89, + 91, + 93, + 95, + 98, + 99, + 102, + 103 + ], + "inside_count": 22, + "outside_rank_histogram": { + "0": 1, + "8": 489, + "7": 22 + }, + "good_messages": [ + 0, + 4, + 8, + 13, + 62, + 92, + 126, + 139, + 172, + 218, + 223, + 248, + 253, + 263, + 300, + 342, + 351, + 372, + 381, + 388, + 392, + 419, + 431 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 1, + "inside": [ + 3, + 5, + 7, + 14, + 15, + 23, + 30, + 31, + 38, + 39, + 53, + 55, + 58, + 59, + 62, + 63, + 70, + 71, + 83, + 87, + 90, + 91, + 94, + 95, + 98, + 99, + 102, + 103 + ], + "inside_count": 28, + "outside_rank_histogram": { + "0": 1, + "8": 483, + "7": 28 + }, + "good_messages": [ + 0, + 4, + 8, + 14, + 31, + 62, + 92, + 108, + 125, + 139, + 172, + 200, + 217, + 223, + 239, + 248, + 254, + 263, + 300, + 324, + 341, + 351, + 367, + 372, + 382, + 388, + 392, + 419, + 431 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 2, + "inside": [ + 3, + 6, + 7, + 14, + 15, + 39, + 54, + 55, + 60, + 61, + 62, + 63, + 70, + 71, + 99, + 103 + ], + "inside_count": 16, + "outside_rank_histogram": { + "0": 1, + "8": 495, + "7": 16 + }, + "good_messages": [ + 0, + 4, + 13, + 14, + 31, + 62, + 172, + 200, + 217, + 218, + 234, + 248, + 251, + 263, + 300, + 388, + 431 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 3, + "inside": [ + 3, + 5, + 6, + 7, + 14, + 15, + 38, + 39, + 70, + 71, + 98, + 99, + 102, + 103 + ], + "inside_count": 14, + "outside_rank_histogram": { + "0": 1, + "8": 497, + "7": 14 + }, + "good_messages": [ + 0, + 4, + 8, + 13, + 14, + 31, + 62, + 139, + 172, + 263, + 300, + 388, + 392, + 419, + 431 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 4, + "inside": [ + 4, + 5, + 6, + 7, + 12, + 13, + 14, + 15, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 71, + 84, + 85, + 86, + 87, + 92, + 93, + 94, + 95, + 100, + 101, + 102, + 103, + 108, + 109, + 110, + 111 + ], + "inside_count": 37, + "outside_rank_histogram": { + "0": 1, + "8": 474, + "7": 37 + }, + "good_messages": [ + 0, + 8, + 11, + 13, + 14, + 26, + 31, + 59, + 62, + 200, + 205, + 217, + 218, + 220, + 223, + 234, + 239, + 248, + 251, + 253, + 254, + 300, + 322, + 324, + 341, + 342, + 352, + 358, + 372, + 375, + 388, + 391, + 400, + 406, + 416, + 419, + 433, + 439 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 5, + "inside": [ + 3, + 4, + 5, + 6, + 7, + 12, + 13, + 14, + 15, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 70, + 71 + ], + "inside_count": 23, + "outside_rank_histogram": { + "0": 1, + "8": 488, + "7": 23 + }, + "good_messages": [ + 0, + 4, + 8, + 11, + 13, + 14, + 26, + 31, + 59, + 62, + 200, + 205, + 217, + 218, + 220, + 223, + 234, + 239, + 248, + 251, + 253, + 254, + 263, + 300 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 6, + "inside": [ + 2, + 3, + 4, + 5, + 6, + 7, + 28, + 29, + 30, + 31, + 36, + 37, + 38, + 39, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 68, + 69, + 70, + 71, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103 + ], + "inside_count": 42, + "outside_rank_histogram": { + "0": 1, + "8": 469, + "7": 42 + }, + "good_messages": [ + 0, + 4, + 7, + 8, + 11, + 13, + 14, + 92, + 95, + 125, + 126, + 136, + 139, + 172, + 175, + 217, + 218, + 220, + 223, + 248, + 251, + 253, + 254, + 260, + 263, + 300, + 303, + 341, + 342, + 348, + 351, + 372, + 375, + 381, + 382, + 388, + 391, + 392, + 395, + 416, + 419, + 428, + 431 + ], + "good_message_span": 8, + "structure": "zero and K_q for q in H; each outside support spans q-perp" + }, + { + "delete": 7, + "inside": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "inside_count": 63, + "outside_rank_histogram": { + "0": 1, + "1": 1, + "7": 126, + "8": 384 + }, + "good_messages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 18, + 19, + 22, + 23, + 26, + 27, + 30, + 31, + 50, + 51, + 54, + 55, + 58, + 59, + 62, + 63, + 194, + 195, + 198, + 199, + 200, + 201, + 204, + 205, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 228, + 229, + 234, + 235, + 238, + 239, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 322, + 323, + 324, + 325, + 330, + 331, + 332, + 333, + 340, + 341, + 342, + 343, + 348, + 349, + 350, + 351, + 352, + 353, + 358, + 359, + 360, + 361, + 366, + 367, + 372, + 373, + 374, + 375, + 380, + 381, + 382, + 383, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 400, + 401, + 406, + 407, + 410, + 411, + 412, + 413, + 416, + 417, + 418, + 419, + 428, + 429, + 430, + 431, + 432, + 433, + 438, + 439, + 442, + 443, + 444, + 445 + ], + "good_message_span": 8, + "structure": "zero, t, K_q and K_q+t for q in H; other outside supports span q-perp", + "normal": 0, + "neighbor_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "common_neighbor_min": 16, + "common_neighbor_max": 16 + } + ], + "structural_checks_passed": true +} diff --git a/research/e8-small-redundancy/binary/parabolic_check.py b/research/e8-small-redundancy/binary/parabolic_check.py new file mode 100644 index 0000000000..c9a791d788 --- /dev/null +++ b/research/e8-small-redundancy/binary/parabolic_check.py @@ -0,0 +1,152 @@ +"""Check the eight root-hyperplane types with exact arithmetic.""" +import gzip +import json +from fractions import Fraction +from pathlib import Path + +SOURCE = Path(__file__).resolve().parents[1] / 'inputs/bit-word.json.gz' +ROOTS = json.load(gzip.open(SOURCE, 'rt'))['lines'] + + +def rank2(words): + pivots = {} + for word in words: + while word: + p = word.bit_length() - 1 + if p not in pivots: + pivots[p] = word + break + word ^= pivots[p] + return len(pivots) + + +def basis2(words): + pivots = {} + for word in words: + while word: + p = word.bit_length() - 1 + if p not in pivots: + pivots[p] = word + break + word ^= pivots[p] + return list(pivots.values()) + + +def rankq(rows): + pivots = {} + for raw in rows: + row = list(map(Fraction, raw)) + for p, basis in sorted(pivots.items()): + if row[p]: + f = row[p] + row = [x - f*y for x,y in zip(row,basis)] + if any(row): + p = next(i for i,x in enumerate(row) if x) + f = row[p] + pivots[p] = [x/f for x in row] + if len(pivots) == 8: + return 8 + return len(pivots) + + +def rankmod(rows, prime=101): + pivots = {} + for raw in rows: + row = [x % prime for x in raw] + for p, basis in sorted(pivots.items()): + if row[p]: + f = row[p] + row = [(x - f*y) % prime for x,y in zip(row,basis)] + if any(row): + p = next(i for i,x in enumerate(row) if x) + f = pow(row[p], -1, prime) + pivots[p] = [(x*f) % prime for x in row] + if len(pivots) == 8: + return 8 + return len(pivots) + + +def rank(rows): + value = rankmod(rows) + return 8 if value == 8 else rankq(rows) + + +all_roots = {tuple(q) for q in ROOTS} | {tuple(-x for x in q) for q in ROOTS} +assert len(ROOTS) == 120 and len(all_roots) == 240 +assert all(sum(x*x for x in q) == 4 for q in all_roots) +for q in all_roots: + for r in all_roots: + dot = sum(x*y for x,y in zip(q,r)) + assert dot % 2 == 0 + assert tuple(x - (dot//2)*y for x,y in zip(q,r)) in all_roots +positive = set() +for q in ROOTS: + if next(x for x in q if x) < 0: + q = [-x for x in q] + positive.add(tuple(q)) +simple = sorted(q for q in positive if not any(tuple(x-y for x,y in zip(q,p)) in positive for p in positive)) +assert len(simple) == 8 and rankq(simple) == 8 +code_basis = basis2(sum((1 ^ (sum(x*y for x,y in zip(q,r))//2 & 1)) << j for j,r in enumerate(ROOTS)) for q in ROOTS) +assert len(code_basis) == 9 +code = [0] +for word in code_basis: + code += [x ^ word for x in code] +assert all(rank([ROOTS[j] for j in range(120) if word >> j & 1]) == 8 for word in code[1:]) +result = {'simple_roots':simple,'gram':[[sum(x*y for x,y in zip(q,r))//2 for r in simple] for q in simple], 'code_basis':code_basis, 'code_weight_histogram':{},'hyperplanes':[]} +for word in code: + w = word.bit_count() + result['code_weight_histogram'][w] = result['code_weight_histogram'].get(w,0)+1 +for delete in range(8): + hb = simple[:delete] + simple[delete+1:] + inside = [j for j,q in enumerate(ROOTS) if rank(hb+[q]) == 7] + outside = [j for j in range(120) if j not in inside] + good = [] + histogram = {} + for index,word in enumerate(code): + r = rank([ROOTS[j] for j in outside if word >> j & 1]) + histogram[r] = histogram.get(r,0)+1 + if r <= 7: + good.append(index) + item={'delete':delete,'inside':inside,'inside_count':len(inside),'outside_rank_histogram':histogram,'good_messages':good,'good_message_span':rank2(good)} + result['hyperplanes'].append(item) + print(delete,len(inside),histogram,'good span',rank2(good),flush=True) +Path(__file__).with_name('parabolic-results.json').write_text(json.dumps(result,indent=2)+'\n') + +root_code = [sum((1 ^ (sum(x*y for x,y in zip(q,r))//2 & 1)) << j for j,r in enumerate(ROOTS)) for q in ROOTS] +message_of_word = {word:i for i,word in enumerate(code)} +for item in result['hyperplanes']: + inside = item['inside'] + outside = [j for j in range(120) if j not in inside] + h = set(inside) + good_words = {code[i] for i in item['good_messages']} + if len(inside) != 63: + assert good_words == {0} | {root_code[q] for q in inside} + for q in inside: + support = [ROOTS[j] for j in outside if root_code[q] >> j & 1] + assert rankq(support) == 7 + assert all(sum(x*y for x,y in zip(ROOTS[q],r)) == 0 for r in support) + item['structure'] = 'zero and K_q for q in H; each outside support spans q-perp' + else: + normals = [q for q in outside if all(sum(x*y for x,y in zip(ROOTS[q],ROOTS[r])) == 0 for r in inside)] + assert len(normals) == 1 + normal = normals[0] + t = root_code[normal] + assert [j for j in range(120) if t >> j & 1] == sorted(inside+[normal]) + assert good_words == {0,t} | {root_code[q] ^ extra for q in inside for extra in (0,t)} + for q in inside: + for extra in (0,t): + support = [ROOTS[j] for j in outside if (root_code[q] ^ extra) >> j & 1] + assert rankq(support) == 7 + assert all(sum(x*y for x,y in zip(ROOTS[q],r)) == 0 for r in support) + neighbors = {q:{r for r in inside if r != q and sum(x*y for x,y in zip(ROOTS[q],ROOTS[r])) != 0} for q in inside} + assert all(rankq([ROOTS[r] for r in neighbors[q]]) == 7 for q in inside) + common = [len(neighbors[q] & neighbors[r]) for i,q in enumerate(inside) for r in inside[i+1:]] + assert min(common) > 0 + item['structure'] = 'zero, t, K_q and K_q+t for q in H; other outside supports span q-perp' + item['normal'] = normal + item['neighbor_ranks'] = [7] * len(inside) + item['common_neighbor_min'] = min(common) + item['common_neighbor_max'] = max(common) + print('E7 common nonorthogonal neighbors:',min(common),max(common),flush=True) +result['structural_checks_passed'] = True +Path(__file__).with_name('parabolic-results.json').write_text(json.dumps(result,indent=2)+'\n') diff --git a/research/e8-small-redundancy/binary/standard_e8.py b/research/e8-small-redundancy/binary/standard_e8.py new file mode 100644 index 0000000000..5a9fd37ed2 --- /dev/null +++ b/research/e8-small-redundancy/binary/standard_e8.py @@ -0,0 +1,52 @@ +from itertools import combinations,product +from fractions import Fraction +import json +from pathlib import Path + +roots=[] +for i,j in combinations(range(8),2): + for s in [-1,1]: + x=[0]*8;x[i]=2;x[j]=2*s;roots.append(tuple(x)) +for signs in product([-1,1], repeat=7): + if sum(x<0 for x in signs)%2==0: roots.append((1,)+signs) +assert len(roots)==120 + +def dot(x,y):return sum(a*b for a,b in zip(x,y)) +def binary_basis(xs): + out={} + for x in xs: + while x: + k=x.bit_length()-1 + if k in out:x^=out[k] + else:out[k]=x;break + return list(out.values()) +def rank_mod(xs,p=101): + bas={} + for row in xs: + row=[x%p for x in row] + for i in range(8): + if row[i]: + if i in bas: + v=row[i];row=[(x-v*y)%p for x,y in zip(row,bas[i])] + else: + inv=pow(row[i],-1,p);bas[i]=[x*inv%p for x in row];break + return len(bas) +K=[sum((1^(dot(x,y)//4&1))<> i) & 1] + if extra_normal and (port & extra_normal).bit_count() % 2: + outside = sorted(set(outside) | {0}) + basis_coeffs = [vector[i] - vector[8] for i in range(8)] + first = outside[0] + for second in outside[1:]: + row = [0] * 64 + for index, sign in ((first, 1), (second, -1)): + if index: + for k, value in enumerate(basis_coeffs): + row[8 * (index - 1) + k] += sign * value + rows.append(row) + descriptors.append([port, first, second]) + return rows, descriptors + + +def rational_kernel(rows): + pivots = {} + for source in rows: + row = list(map(Fraction, source)) + for pivot in sorted(pivots): + coefficient = row[pivot] + if coefficient: + row = [x - coefficient * y for x, y in zip(row, pivots[pivot])] + if any(row): + pivot = next(i for i, value in enumerate(row) if value) + scale = row[pivot] + pivots[pivot] = [value / scale for value in row] + free = [i for i in range(64) if i not in pivots] + kernel = [] + for column in free: + vector = [Fraction(0)] * 64 + vector[column] = Fraction(1) + for pivot in sorted(pivots, reverse=True): + vector[pivot] = -sum( + pivots[pivot][i] * vector[i] for i in range(pivot + 1, 64) + ) + assert all(sum(a * b for a, b in zip(row, vector)) == 0 for row in rows) + kernel.append(vector) + return len(pivots), kernel + + +def modular_rank(rows, prime): + matrix = [[value % prime for value in row] for row in rows] + rank = 0 + for column in range(64): + pivot = next((i for i in range(rank, len(matrix)) if matrix[i][column]), None) + if pivot is None: + continue + matrix[rank], matrix[pivot] = matrix[pivot], matrix[rank] + inverse = pow(matrix[rank][column], -1, prime) + matrix[rank] = [(value * inverse) % prime for value in matrix[rank]] + for i in range(rank + 1, len(matrix)): + coefficient = matrix[i][column] + if coefficient: + matrix[i] = [(a - coefficient * b) % prime for a, b in zip(matrix[i], matrix[rank])] + rank += 1 + return rank + + +def main(): + certificate_path = sys.argv[1] + with open(certificate_path, "rb") as handle: + certificate_bytes = handle.read() + certificate = json.loads(gzip.decompress(certificate_bytes)) + labels, vectors, heights = family() + assert certificate["h"] == 9 and certificate["v"] == 120 + assert certificate["ports"] == labels + + scatter_entries = 0 + for source, source_height in zip(vectors, heights): + scatter = [(Fraction(source[i]) - Fraction(source_height, 3)) / 2 for i in range(9)] + assert sum(scatter) == 0 + for target, target_height in zip(vectors, heights): + actual = sum(scatter[i] * (target[i] - target_height) for i in range(9)) + expected = Fraction(sum(a * b for a, b in zip(source, target)) - source_height * target_height, 2) + assert actual == expected + scatter_entries += 1 + assert scatter_entries == 14400 + + expected_kernel = [] + for i in range(1, 9): + row = [0] * 8 + row[0] = 1 + if i < 8: + row[i] = -1 + expected_kernel.extend(row) + + results = [] + for weight in (0, 1, 3, 5, 7): + extra_normal = sum(1 << i for i in range(1, weight + 1)) + rows, descriptors = equations(labels, vectors, extra_normal) + rank, kernel = rational_kernel(rows) + modular = {str(prime): modular_rank(rows, prime) for prime in (101, 103)} + assert all(value == rank for value in modular.values()) + if weight == 0: + assert rank == 63 and kernel == [list(map(Fraction, expected_kernel))] + else: + assert rank == 64 and not kernel + results.append({ + "extra_normal_weight": weight, + "extra_normal": extra_normal, + "orbit_size": 1 if weight == 0 else comb(8, weight), + "equations": len(rows), + "rational_rank": rank, + "nullity": 64 - rank, + "modular_ranks": modular, + "equations_sha256": hashlib.sha256(json.dumps(rows, separators=(",", ":")).encode()).hexdigest(), + }) + + supports = [] + for i in range(9): + support = [port for port, vector, height in zip(labels, vectors, heights) if height - vector[i]] + assert len(support) == 64 and binary_rank(support) == 8 + assert all((port >> i) & 1 == 0 for port in support) + supports.append({"coordinate": i, "support_size": len(support), "binary_rank": binary_rank(support)}) + + print(json.dumps({ + "certificate_sha256": hashlib.sha256(certificate_bytes).hexdigest(), + "variables": 64, + "exact_scatter_entries_checked": scatter_entries, + "nondegenerate_tightening_frames": sum(comb(8, weight) for weight in (1, 3, 5, 7)), + "results": results, + "baseline_kernel_rows": [expected_kernel[8 * i:8 * (i + 1)] for i in range(8)], + "canonical_total_supports": supports, + "scope": "Nine rational totals, one supported in each coordinate hyperplane, whose span contains the canonical E8 rank-eight coefficient space.", + "conclusion": "The coefficient space of all nine totals is unique. Up to nonzero individual scales, the totals are t-a_i. None can have support in a proper subspace of its coordinate hyperplane.", + }, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/e8-small-redundancy/coordinate/rigidity_review_72vars.py b/research/e8-small-redundancy/coordinate/rigidity_review_72vars.py new file mode 100644 index 0000000000..7a933a92a8 --- /dev/null +++ b/research/e8-small-redundancy/coordinate/rigidity_review_72vars.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +"""Check the rigidity equations with 72 variables over F_107. + +Use nine coefficients for each of e_1 through e_8. Add one zero-sum +equation for each vector. Set e_0 to zero. At each port, add all pairs +of equality equations for the totals that must be zero at that port. +Do not import repository modules. +""" + +import gzip +import hashlib +import json +import sys +from itertools import combinations + + +def rank_modulo(rows, prime): + basis = {} + for source in rows: + row = [value % prime for value in source] + for column in sorted(basis): + if row[column]: + scale = row[column] + row = [(x - scale * y) % prime for x, y in zip(row, basis[column])] + column = next((i for i, value in enumerate(row) if value), None) + if column is not None: + inverse = pow(row[column], -1, prime) + basis[column] = [(value * inverse) % prime for value in row] + return len(basis) + + +def main(): + items = [] + for triple in combinations(range(9), 3): + vector = [int(i in triple) for i in range(9)] + items.append((sum(1 << i for i in triple), vector)) + for i, j in combinations(range(9), 2): + vector = [0] * 9 + vector[i], vector[j] = 1, -1 + items.append((511 - (1 << i) - (1 << j), vector)) + + with open(sys.argv[1], "rb") as handle: + certificate_bytes = handle.read() + certificate = json.loads(gzip.decompress(certificate_bytes)) + assert certificate["h"] == 9 + assert certificate["v"] == 120 + assert certificate["ports"] == [port for port, vector in items] + + results = [] + for weight in (0, 1, 3, 5, 7): + normal = sum(1 << i for i in range(1, weight + 1)) + rows = [] + for i in range(1, 9): + row = [0] * 72 + row[9 * (i - 1):9 * i] = [1] * 9 + rows.append(row) + for port, vector in items: + outside = {i for i in range(9) if port & (1 << i)} + if (port & normal).bit_count() % 2: + outside.add(0) + for i, j in combinations(sorted(outside), 2): + row = [0] * 72 + if i: + for k, value in enumerate(vector): + row[9 * (i - 1) + k] += value + if j: + for k, value in enumerate(vector): + row[9 * (j - 1) + k] -= value + rows.append(row) + rank = rank_modulo(rows, 107) + assert rank == (71 if weight == 0 else 72) + results.append({ + "extra_normal_weight": weight, + "rows": len(rows), + "rank_mod_107": rank, + "nullity_mod_107": 72 - rank, + }) + + print(json.dumps({ + "certificate_sha256": hashlib.sha256(certificate_bytes).hexdigest(), + "certificate_ports_match": True, + "variables": 72, + "field_prime": 107, + "results": results, + "nondegenerate_subframes_of_F0": sum( + 1 for normal in range(2, 512, 2) if normal.bit_count() % 2 + ), + "scope": "Independent modular check of the normalized equations; no repository modules or Lean execution.", + }, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/e8-small-redundancy/inputs/BIT-NOTICE.md b/research/e8-small-redundancy/inputs/BIT-NOTICE.md new file mode 100644 index 0000000000..0f8eec4cfa --- /dev/null +++ b/research/e8-small-redundancy/inputs/BIT-NOTICE.md @@ -0,0 +1,42 @@ +# Attribution and licence + +Target-prefix mixing (`code/mix_target.py`, verbatim from PR450, Apache-2.0): +DreamingOfClouds with Claude Opus 5.5 (Anthropic) assistance. +Rank151 kernel selection (hosting-aware donor search), repackaging, mixing +integration and fresh hosting selection: Rohan Arun with Claude Opus 5.5 +(Anthropic) assistance. This directory is a copy of chafreaky's PR451 package +`r740-hosted-rank149`; only the data files, expected values, kernel constants, +the added mixing step in `code/rebuild.py` and the relaxed bit-binding +assertion in `code/assemble.py` (binding side is reported) differ. +All PR451 credits below are retained. + +Rank149 hosting-aware response-kernel selection, explicit residual routes, +eleven-stage complex integration, independent audits, fractional depth row +bound, complete invoices and release wrapper: chafreaky with substantial +OpenAI Codex assistance. Apache-2.0. Credit does not imply review or endorsement. + +Complete PR445/444/443 and their source packages are retained byte-identically. +All inherited notices remain in those directories. + +- Zhihao Chen / jacklightChen, PR377 (OpenAI Codex assistance): compressed + complex routes, exact Z4 data phases, idle factorization, terminal and + orthogonal-cover corrections. `upstream377/data_phases.py` is pinned + verbatim at `d0a620fcc99ba012468d61d01f5bb14007076d50`. +- icekylinx, PR433 (OpenAI Codex assistance): heterogeneous centres, exact + complex local word and replay, phase evidence and local finite invoices. +- DaysSky, PR442 (Anthropic Claude assistance): idle-data hosting lemma, + integer selection representation, ownership expansion and assembly. +- eumemic, PR436 (Anthropic Claude assistance), PR440/441 (OpenAI Codex + assistance): R740 local word and primitive/B-frame retiming witnesses. +- chafreaky, PR417 and earlier kernel lineage (Anthropic Claude assistance), + PR439/443/444/445 (OpenAI Codex assistance): shared-donor response kernel, + residual isometries, replicated banks, hosting, eleven-stage bit geometry + and elementary orthogonal-cover row count. +- Henry Grant / hcg890, PR234: inherited restored-row divisor argument, + retained verbatim in `../r740-hosted-eleven/proof/` with its full notice. +- Rohan Arun PR434/447, Dylan Crow PR370, Jacob Sussman and earlier authors: + see the preserved parent notices. PR447 is a comparison point, not a + source dependency of the new kernel or complex construction. + +All-size and hosting assumptions remain explicit. No unconditional theorem +or new Lean proof is claimed. diff --git a/research/e8-small-redundancy/inputs/COMPLEX-NOTICE.md b/research/e8-small-redundancy/inputs/COMPLEX-NOTICE.md new file mode 100644 index 0000000000..8bbad70301 --- /dev/null +++ b/research/e8-small-redundancy/inputs/COMPLEX-NOTICE.md @@ -0,0 +1,78 @@ +# Attribution and scope of new work + +Jacob Sussman supplied the E8 label family, circuit, scatter, frame scheduler, +checkers, price routines, and general proof framework in +`jacobalansussman/wht-power-saving-lean`, commit +`9c94857bbaee886f8649edee0bc2d3c738f9555e`. + +`data/original.json.gz` is an unchanged copy from that commit. The new +certificate derives from that file. This package uses the repository's +[Apache-2.0 license](../../LICENSE). The source notices that apply to the +retained certificate are copied below. + +DaysSky's CrocSwap PR352 supplies the connection to the complex branch and the +exact coarse-moment convention used here. Its commit +`04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2`, source paths, and hashes are +recorded in `sources.json`. Prior frame-retiming contributions +include CrocSwap PR328 and PR350. No claim of priority for the general method is +made. + +The new work consists of four explicit frame changes, a deterministic +generator, independent scalar and frame checks, exact rational cost bounds, +and the short cost proof. OpenAI Codex and its research agents supplied +substantial assistance. New contributions are +offered under the repository's Apache-2.0 license. + +Attribution does not imply review or endorsement by the credited authors. + +## Upstream notice excerpts + +The following text is copied from the copyright header and sections 4 and 8 +of the [upstream NOTICE](https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/NOTICE). +References within these excerpts refer to that source repository. + +```text +Walsh-Hadamard power saving (wht-power-saving-lean) +Copyright 2026 Jacob Sussman + +Repository: https://github.com/jacobalansussman/wht-power-saving-lean + +4. How the new files were made. + Jacob Sussman made the new files on 2026-10-08, 2026-10-09 and 2026-10-10 + by directing a team of AI agents (Claude). The agents wrote the new Lean + files, the certificate data and the generator scripts. They made the + rebuild scripts under tools/rebuild/, in part by adapting programs of + CrocSwap/integer-mult-bounds (section 6): ten of the thirteen on + 2026-10-09, tidied for this repository on 2026-10-10, and three on + 2026-10-10. On 2026-10-10 they also wrote the search programs under + tools/e8/ and found with them the certificate of the fourth result + (section 8). See README.md, section 4. + +8. The certificate of the fourth result and the search programs. + tools/certificate/gcert1-e8-r783.json.gz, the Lean data modules + generated from it (Work/GCert/Data/Gen/E8*.lean, Work/GCert/Data/Gen/E8/ + and the modules of Work/GCert/Data/ with E8 or B2Ge8 in their names) and + the Python programs under tools/e8/ were made by the agents for this + repository on 2026-10-10 (section 4). The circuit in that certificate + is not the circuit of section 6, and no data file of + CrocSwap/integer-mult-bounds was loaded to make it. It uses three + devices that were published by others in pull requests to that + repository: + - the in-place pair, a + b and a - b formed on the two arrays that held + a and b: icekylinx (#184), carried in #191 and #193 (ikeboy); + - the re-use of a finished helper with a compensating read: jamesyc + (#124) and eumemic (#143); + - the late pairing rule, the choice of which finished helper a new + value takes: Chafik Boukhalfa (the account chafreaky), #200 and #233, + and pull request #2 of this repository. The search programs apply the + idea with a greedy rule of their own; his program, his pairs and his + certificate were not used. + No program of that repository is included in tools/e8/, imported or + run by it. The programs of tools/e8/ have not been compared statement + by statement with the programs of that repository, as those of + tools/rebuild/ were (section 6). The integer programme of + tools/e8/ is solved with the open-source solver HiGHS, called through + SciPy (scipy.optimize.milp), with NumPy; none of the three is included + here. The credits, with links, are in README.md ("Whose ideas the new + unit uses") and in RELATED-WORK.md, section 8. +``` diff --git a/research/e8-small-redundancy/inputs/bit-word.json.gz b/research/e8-small-redundancy/inputs/bit-word.json.gz new file mode 100644 index 0000000000..0d4d5bb78e Binary files /dev/null and b/research/e8-small-redundancy/inputs/bit-word.json.gz differ diff --git a/research/e8-small-redundancy/inputs/complex-word.json.gz b/research/e8-small-redundancy/inputs/complex-word.json.gz new file mode 100644 index 0000000000..0bd0bacf74 Binary files /dev/null and b/research/e8-small-redundancy/inputs/complex-word.json.gz differ diff --git a/research/e8-small-redundancy/review/INDEPENDENT-REVIEW.md b/research/e8-small-redundancy/review/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..a0df2f4346 --- /dev/null +++ b/research/e8-small-redundancy/review/INDEPENDENT-REVIEW.md @@ -0,0 +1,195 @@ +# Independent review of the fixed E8 package + +Reviewer: a separate OpenAI Codex agent, `/root/e8_cost_review`. +This is an independent agent review. It is not human review or a proof-kernel +certificate. The reviewer did not write the submitted mathematical proofs. + +Review result: **PASS for the stated scope**. No material mathematical issue +remains in the reviewed package. Publication is justified as two related, +scoped obstructions. Neither result is a supplier construction or a verified +improvement to the complete kappa bound. + +The reviewed package is +`work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy`. +`REVIEWED-FILE-HASHES.json` records SHA-256 for all 30 reviewed files. +The final check confirmed that those bytes did not change during replay. +The local PR description standard was read before this review: +`/Users/aliromman/Projects/IntegerMultiplicationBounds/PR-DESCRIPTION-STANDARD.md`. + +## Claims checked + +1. Over Q, nine totals assigned to the nine specified binary coordinate + hyperplanes, with span containing the canonical E8 coefficient space, + are individual nonzero scalar multiples of `a_i-t`. Each total has 64 + nonzero coefficients. Its binary source labels span its full + dimension-eight coordinate hyperplane. +2. Over F2, every factorization of the fixed 120-line corrector matrix + `K(q,r)=1+(q dot r)/2 mod 2` with at most eleven outer-product terms has + rational source-reader pairing-rank sum at least 72. Factors outside + the rank-nine code are permitted. + +These are different coefficient fields and different support prices. The +first uses rational coefficients and binary label spans. The second uses +binary coefficients and the rational Euclidean pairing of root spans. +Neither theorem allows substitution of one price for the other. + +The physical interpretation of the second bound requires separate scalar +copy trees, drop-free gathering, and readers at the required orthogonal +frames. The written algebraic theorem does not require that interpretation. +Shared delivery, changed matrices, punctures, and twelve or more terms are +outside its scope. No complete bill for access, restoration, hosting, +physical tapes, or recursive children is supplied or claimed. + +## Proof review + +The rational proof is complete within its hypotheses. The pair equations +and triple equations prove full binary support span for each nonzero +element of the rank-eight coefficient space. This forces nine independent +retained totals and a one-dimensional quotient. Quotient normalization +then puts every pairwise difference in that coefficient space. The common +forbidden triples force each difference to be a multiple of `a_i-a_j`. +The three-index consistency equation makes that scalar common. Evaluation +at a forbidden coordinate determines the remaining common function. +The eight pair rows prove that the actual scatter has exactly the required +row space. The displayed scatter identity proves that the classified +totals can reconstruct it. + +The source-frame argument tracks source coefficients separately from +arbitrary initial helper dirt. Nested frame changes and common-frame gates +preserve that invariant. Cancellation does not create a forbidden source +coefficient. Thus the stated frame and copy-charge consequence follows for +the specified certificate format. This is a written bridge, not a replay of +the whole circuit. + +The binary coset proof covers all root hyperplanes. A root support of rank +at most seven extends to a rank-seven root flat. A Weyl transformation can +move its normal into a closed dominant chamber. The positive-root expansion +then identifies a seven-simple-root subsystem. This explains why all eight +deletions suffice; they are not sampled hyperplanes. The same argument +within E7 makes its seven deletions sufficient for every proper E7 root +span. The primary replay checks reflection closure and the finite ranks. +The reviewer also checked integral, single-sign expansions of all 240 +signed roots in the reported simple basis without importing package code. +The Weyl-chamber reduction remains written mathematics. + +The ten-term argument uses the complete description of the low-rank words +in each outside coset. The non-E7 case has pairwise orthogonal isolated +roots. The E7 case also needs complementary support rank and common +neighbors; the proof uses both. Their bounds give a total coset defect of +at most eight. + +The eleven-term proof includes rank-eight star centres and omitted centres. +This is necessary for its defect identity. If the sum of the three centres +is a nonzero codeword, the small-change lemma forces the residual support +into one E7 hyperplane. Any omitted centre then contains its normal in the +span of the removed orthogonal roots. If that normal is not one of those +roots, its four nonzero coefficients contradict the pairwise intersection +bound. The remaining normal-root cases each give a basis dependence. +If the centre sum is zero, the three dual vectors in the lifted root spaces +prove the bound on distinct satellite roots. The duplicate count covers +all pair types. The sole possible defect-17 equality case forces a rank-one +centre and contradicts a second centre's rank eight. + +The factor-rank reduction is complete. Sylvester's inequality leaves the +six listed rank pairs. Zero terms can be removed. Repeated columns can be +merged without increasing the pairing-rank objective, including terms of +zero cost. The `(10,10)` case uses both coset budgets. The `(9,11)` case and +its transpose reduce to the eleven-dimensional basis theorem. Fewer than +nine terms are impossible by binary matrix rank. + +## Fresh checks + +All mathematical checks ran sequentially with the Python standard library +on CPython 3.14.7. No package module was imported by the separate control +script. Run from the workspace root: + +```sh +python3 -B work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy/verify.py +PYTHONOPTIMIZE=1 python3 -I -O -B work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy/verify.py +python3 -B work/project-final-cleanup-20261022/reviews/e8-cost/independent_controls.py +``` + +The first replay passed in 13.26 seconds. The final isolated and optimized +replay passed in 12.92 seconds. Its child commands use `-E -B`, so inherited +Python environment flags cannot disable historical assertions. All 30 +package files were unchanged. The expected final lines were: + +```text +PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa +PASS_E8_INDEPENDENT_CONTROLS root_expansions=240 coset_words=512 rejected=5 +``` + +The replay reproduces all saved mathematical receipts, all 511 nonzero +codeword supports, all eight E8 and seven E7 deletion cases, the outside +weight histogram, and the exact similarity between both coordinate models. +It also reproduces the rational coordinate ranks, 14,400 scatter entries, +and the separate 72-variable modular ranks. + +The separate checks give one complete outside-coset support-rank histogram: +one word of rank one, one word of rank seven, and 510 words of rank eight. +Its total defect is exactly eight. Deleting a root from its own corrector +row lowers support rank to seven. Removing the affine constant from the +binary kernel changes its rank from nine to eight. These are exact boundary +checks, not a search for a new construction. + +Five negative controls passed. They reject an input hash change, an omitted +root, a changed certificate port order, and a false receipt with its hash +updated. A malformed root norm with an updated hash is also rejected at the +original assertion while `PYTHONOPTIMIZE=1` is set and the wrapper uses +isolated optimized mode. Each mutation runs only in a temporary copy. + +One intermediate optimized replay passed its mathematical checks but saw a +concurrent wrapper edit. Its file-immutability check therefore failed. +That result is retained in `verify-isolated-optimized-command.json`; it is +not the final receipt. The subsequent final replay used stable files and +passed both mathematical and immutability checks. + +No Lean check, complete supplier replay, repository-wide build, hosted CI, +or independent human certification was run. + +## Dependencies, credit, and overlap + +`PUBLIC-DEPENDENCY-BYTE-CHECKS.json` records live GitHub reads of the two +input archives, PR446's proof, and the pinned `gx.py` source. Both archives +match the package byte for byte. All four exact source targets resolve. +The source notices retain Jacob Sussman's certificate credit and the +historical bit-word contributors. PR446's copy-tree hypothesis remains an +explicit dependency of the physical interpretation. Substantial AI help +is disclosed, and the historical reviews are identified as agent reviews. + +At main commit `cef4b52f2a59009865bf8eabde1be3f159063703`, the PR3755 +one-coset package uses scalar fields of characteristic other than two and +binary support prices. It does not imply the binary-factor theorem here. +It subsumes the older nine-small-total numerical obstruction, which this +package correctly omits. Its equality conditions expressly do not classify +scalar coefficients. The present fixed-coordinate classification retains +a separate use. + +The tensor E8 package covers the minimum `9^d` terms, and its overcomplete +corollary requires both factors to remain in the code. The ten- and +eleven-term theorem here permits factors outside that code. The R429 +package concerns a punctured 111-line matrix and gives different bounds. +Open PR3045 excludes factors outside its root code and overcomplete decoder +cases from its stated coverage. Open PR3040 concerns fitting-matrix +rigidity, not this coefficient or pairing-rank classification. + +`OVERLAP-CHECK.json` records the three main-file hashes and the 315-entry +open-PR snapshot used. All titles and bodies in that snapshot were searched +for relevant field, term-count, coset, and coordinate-hyperplane claims. +This is bounded overlap evidence, not a claim of exhaustive novelty across +all closed PRs or unpublished work. + +## Resolved findings + +The initial ten-term proof did not separate its algebraic objective from +its physical interpretation clearly. It now defines the exact rational +pairing-rank sum and applies PR446 only to the physical interpretation. +The coordinate proof now links its exact `gx.py` source. A separate package +review found the inherited-optimization risk in historical assertions; the +E8 wrapper now uses the standard `-E` child flag. The final replay and a +targeted negative control check that fix. No mathematical source change was +needed, and no frozen historical source was rewritten. + +The coordinating agent must still check the final PR description, exact +published commit links, rendered Markdown, and published readback. This +review does not assert those later publication checks have occurred. diff --git a/research/e8-small-redundancy/review/OVERLAP-CHECK.json b/research/e8-small-redundancy/review/OVERLAP-CHECK.json new file mode 100644 index 0000000000..1114a097f2 --- /dev/null +++ b/research/e8-small-redundancy/review/OVERLAP-CHECK.json @@ -0,0 +1,40 @@ +{ + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "main_source_files": [ + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/e8-one-coset-deficiency/README.md", + "sha256": "3f20bd9b8dc51f7d3d05fc87398ae4a1612d5a10123a721ae2fa033f1b7838be" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/tensor-e8-copy-floor/README.md", + "sha256": "c270f839965b394cc54f314e536ce1b1017b340c99aa3a1000ff7b9c5f9d4b3d" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/r429-binary-reader-floors/README.md", + "sha256": "b79cb199cb41c1149a4a291cd77983c62425f35402e59760a6bb5d19fb155053" + } + ], + "open_pr_snapshot": { + "path": "work/project-final-cleanup-20261022/OPEN-PRS.json", + "sha256": "e0413ab0c3f982d9f35949478226b6617131708fae1469d49e3eb08e82a098e5", + "count": 315 + }, + "additional_open_pr_scopes_checked": [ + { + "number": 3045, + "title": "Non-dense fitting B: every E8 term with x\u00b7y \u2260 0 has rank \u2265 9; square root-code floors E8 \u2265 72, P112 \u2265 64, P104 \u2265 56, D4 \u2265 12 for any fitting B (no \u03ba claim)", + "headRefOid": "16feea078f5542964ae85ca1b1f35bb94314ae78", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3045" + }, + { + "number": 3040, + "title": "Rank-8 rigidity of the E8 pattern with arbitrary extra zeros after deleting any at most 8 lines (hypothesis (1) of Lemma RIGD; no kappa claim)", + "headRefOid": "53fc5af5b778b8bbe6472d69a4f112d76febc108", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3040" + } + ], + "coverage": "Read the three main package README scopes; searched all 315 open PR titles and bodies for E8, one-coset, term counts, rank72 and coordinate-hyperplane overlap; read PR3045 and PR3040 scopes. This is not an exhaustive novelty proof across closed or unpublished work." +} diff --git a/research/e8-small-redundancy/review/PUBLIC-DEPENDENCY-BYTE-CHECKS.json b/research/e8-small-redundancy/review/PUBLIC-DEPENDENCY-BYTE-CHECKS.json new file mode 100644 index 0000000000..f889517cd2 --- /dev/null +++ b/research/e8-small-redundancy/review/PUBLIC-DEPENDENCY-BYTE-CHECKS.json @@ -0,0 +1,46 @@ +[ + { + "repo": "CrocSwap/integer-mult-bounds", + "commit": "c4df4fdbf411f047ff7d63c73c432e828e94d924", + "path": "research/r740-hosted-rank151-mixed/data/word.json.gz", + "git_blob": "0d4d5bb78eda51ed2f98b0364b8172f775d9ccfe", + "sha256": "4e0e45082510c35af95e27e79ffda272b61ae97121685d90037df7901faf8617", + "bytes": 55386, + "status": "PASS", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/c4df4fdbf411f047ff7d63c73c432e828e94d924/research/r740-hosted-rank151-mixed/data/word.json.gz", + "package_path": "inputs/bit-word.json.gz", + "byte_match": true + }, + { + "repo": "jacobalansussman/wht-power-saving-lean", + "commit": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "path": "tools/certificate/gcert1-e8-r783.json.gz", + "git_blob": "0bd0bacf744f1c31419e05b834e34a92be77ae57", + "sha256": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "bytes": 21883, + "status": "PASS", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/tools/certificate/gcert1-e8-r783.json.gz", + "package_path": "inputs/complex-word.json.gz", + "byte_match": true + }, + { + "repo": "CrocSwap/integer-mult-bounds", + "commit": "309482849b6ddf34db998f53612d34c19f6e3233", + "path": "research/format-obstructions/PROOF.md", + "git_blob": "d2e0ffc6639bf3504b68bccc381a0ee172f98fef", + "sha256": "7a8c3bab633c08e7d96297dec9f9e7ed68d6bd0e076b73310c7d6b08a16df017", + "bytes": 33908, + "status": "PASS", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/309482849b6ddf34db998f53612d34c19f6e3233/research/format-obstructions/PROOF.md" + }, + { + "repo": "jacobalansussman/wht-power-saving-lean", + "commit": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "path": "tools/gx/gx.py", + "git_blob": "6d14c0a976146eb881c1e3897b2476f8633d4e9c", + "sha256": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "bytes": 13006, + "status": "PASS", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/9c94857bbaee886f8649edee0bc2d3c738f9555e/tools/gx/gx.py" + } +] diff --git a/research/e8-small-redundancy/review/REVIEWED-FILE-HASHES.json b/research/e8-small-redundancy/review/REVIEWED-FILE-HASHES.json new file mode 100644 index 0000000000..88c2fe71ed --- /dev/null +++ b/research/e8-small-redundancy/review/REVIEWED-FILE-HASHES.json @@ -0,0 +1,32 @@ +{ + "COORDINATE-PROOF.md": "74cc1758d25ad4a598082a9da3df3835701c603accae1c9be92a83bfb849d8c3", + "ELEVEN-PROOF.md": "afa044fce728f8b5a17217a26cd51aa5261afde3065f0cd4e8c8b5c9121de302", + "ORIGINS.json": "3f0ba7f39f83c646c7f51db3fe3da942a874d05d94974ac6d9c19ff7bdce7d9f", + "README.md": "ba9d62c9fcf2a9913edd7c8985d4a6aae365e4c4762551ba9d84cd06dc8c0818", + "SOURCE-HASHES.json": "34c5c399da9905f6f8a7d0a04f8f92757c740d5b065da2ffb7ad57e12433756a", + "SOURCES.json": "e7a8618da02faccd9ceca1b57bfacf0ce1503877cd0d828c360f53771aab1ee2", + "TEN-PROOF.md": "f3bab259f11cc14415b0d1a242e76ca8371094d7814686e7251ff5b1579fb572", + "binary/e7-complements.json": "5a404b3158f7ee8fb4d5dd418b4dd5da6973934873f7c6ad6d5679f0c046f5e3", + "binary/e7_complements.py": "f6dda16ec0f9dd8a349b633a59c3dc167fa408e48d89592e595ad55f60805626", + "binary/eleven-facts.json": "c739190ae3ed151720a166b18cd50e5812c31a86351d3e5cf0a74d6c7f18adaf", + "binary/eleven_facts.py": "65c02ecc24c26f1a39f5081f5b1d0b94ad24578a1ae008d59d486dafeb4a36e0", + "binary/independent-coordinate-map.json": "96e699d144215dd561ca1fd7e3174cb914460738cea83eb8742bae0365a0ef95", + "binary/independent-eleven-facts.json": "7365b244ae3448a063dea4ee7070c716c1b73a9fff9f85d260d8dd57a68ca638", + "binary/independent-structure-result.json": "c07c8e7439c45f7069a62f87174db558176c61cc48b8de8c04c2786f90a34054", + "binary/independent_coordinate_map.py": "c945811051664249d618d7f2784727adb218f4dfdab996b28948f5a624df1785", + "binary/independent_eleven_facts.py": "e5fa81f7652c21a9554fbf007624c85d982bc5d6d677203762018974cb2cf574", + "binary/independent_structure.py": "cf882c06e74f2badbca7c1efa1a584e92c63e1e6d1700d94a9283bfd676db746", + "binary/parabolic-results.json": "5d86cc60d2447de2569d68f646c391c5358255c9c301f4d9f5007303abfed8ed", + "binary/parabolic_check.py": "d687708f7d18fc070240f6e78f2e04a5fc6686bce8cc592f7fdb31fd53a77ce4", + "binary/standard_e8.py": "e357acc9af0ec645953aab0a3930735a8d368bf3ef3c5f329e0f67f1d7db3bcb", + "coordinate/coordinate_totals_rigidity.json": "3c6451e577588bad30d69cdf1d03e8188233def2b2298ce019785189f255e6c7", + "coordinate/coordinate_totals_rigidity.py": "eb8b43b61ae39167a2a50b328133cc855ae8af93b8b0dc662271805da9bae87f", + "coordinate/rigidity_review_72vars.py": "f8ff34c96a1caea91a587fbc489e0d5900ac49a85e2f227b3d6e6d43180b3d8c", + "inputs/BIT-NOTICE.md": "8162cded5bbb985cbea704fd2e05e35133ae5efea3a0294b7aad8eae2a340f8b", + "inputs/COMPLEX-NOTICE.md": "d90e498b08ebc83951ae44f5b3c507eac314ee03e7cab53df675e7a86da9046b", + "inputs/bit-word.json.gz": "4e0e45082510c35af95e27e79ffda272b61ae97121685d90037df7901faf8617", + "inputs/complex-word.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "reviews/BINARY-HISTORICAL.md": "3670d15cbc464b2f5992a3608c3b0a6228b07b709b6138f68cbea6a360ea5cee", + "reviews/COORDINATE-HISTORICAL.md": "35a6e6df37db38509ea20d6e59c16d1cc64c035f7e316784e17d715b6fea0bcd", + "verify.py": "ec852870bd2884d8b83322e7015acfd5a8c70466ba2789219aa63cda9b89aa9b" +} diff --git a/research/e8-small-redundancy/review/STATUS.json b/research/e8-small-redundancy/review/STATUS.json new file mode 100644 index 0000000000..c07201da8d --- /dev/null +++ b/research/e8-small-redundancy/review/STATUS.json @@ -0,0 +1,20 @@ +{ + "status": "PASS_SCOPED_PUBLICATION", + "reviewer": "separate OpenAI Codex agent /root/e8_cost_review", + "utc": "2026-10-23T04:08:28.568649+00:00", + "package_files": 30, + "unresolved_material_findings": [], + "new_kappa": false, + "final_replay_exit_code": 0, + "package_bytes_unchanged": true, + "negative_controls": 5, + "review_sha256": "ff4e589127001c40dfffa3e5d01bd17251c02f11e23e6aadbe287e72e6480c18", + "reviewed_hash_manifest_sha256": "8da0db729fb18d06de907b04bcebeae3d1571452bba7d8962a862756b3105024", + "independent_control_script_sha256": "47be602102c35c9254a80969166a6bf9e5c1c672ee9d945c2e10818fc2e3b764", + "publication_checks_pending": [ + "final description", + "exact contribution links", + "GitHub rendering", + "published readback" + ] +} diff --git a/research/e8-small-redundancy/review/independent-controls.json b/research/e8-small-redundancy/review/independent-controls.json new file mode 100644 index 0000000000..61bfabdf45 --- /dev/null +++ b/research/e8-small-redundancy/review/independent-controls.json @@ -0,0 +1,85 @@ +{ + "status": "PASS", + "package": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy", + "independent_imports": [], + "signed_root_expansions": 240, + "simple_basis_rank": 8, + "root_coordinates_integral_and_one_sign": true, + "binary_kernel_rank": 9, + "linear_kernel_without_affine_constant_rank": 8, + "unit_coset_support_rank_histogram": { + "1": 1, + "7": 1, + "8": 510 + }, + "unit_coset_total_defect": 8, + "root_row_with_own_root_removed_rank": 7, + "rejection_controls": [ + { + "name": "input_hash_corruption", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py" + ], + "exit_code": 1, + "environment_additions": {}, + "expected_stderr": "Source hash mismatch: inputs/bit-word.json.gz", + "actual_stderr": "Traceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 17, in \n require(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == expected,\n ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n 'Source hash mismatch: ' + name)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 14, in require\n raise ValueError(message)\nValueError: Source hash mismatch: inputs/bit-word.json.gz\n" + }, + { + "name": "one_root_omitted", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/binary/parabolic_check.py" + ], + "exit_code": 1, + "environment_additions": {}, + "expected_stderr": "AssertionError", + "actual_stderr": "Traceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/binary/parabolic_check.py\", line 75, in \n assert len(ROOTS) == 120 and len(all_roots) == 240\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nAssertionError\n" + }, + { + "name": "assertions_active_with_inherited_optimization", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-I", + "-O", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py" + ], + "exit_code": 1, + "environment_additions": { + "PYTHONOPTIMIZE": "1" + }, + "expected_stderr": "assert all(sum(x*x for x in q) == 4 for q in all_roots)", + "actual_stderr": "Traceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 32, in \n run('binary/' + script)\n ~~~^^^^^^^^^^^^^^^^^^^^\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 26, in run\n require(completed.returncode == 0, script + '\\n' + completed.stderr)\n ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 14, in require\n raise ValueError(message)\nValueError: binary/parabolic_check.py\nTraceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-small-redundancy-r42z3p4y/package/binary/parabolic_check.py\", line 76, in \n assert all(sum(x*x for x in q) == 4 for q in all_roots)\n ~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nAssertionError\n\n" + }, + { + "name": "certificate_port_order_changed", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/coordinate/coordinate_totals_rigidity.py", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/inputs/complex-word.json.gz" + ], + "exit_code": 1, + "environment_additions": {}, + "expected_stderr": "AssertionError", + "actual_stderr": "Traceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/coordinate/coordinate_totals_rigidity.py\", line 179, in \n main()\n ~~~~^^\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/coordinate/coordinate_totals_rigidity.py\", line 115, in main\n assert certificate[\"ports\"] == labels\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nAssertionError\n" + }, + { + "name": "wrong_receipt_with_updated_manifest", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py" + ], + "exit_code": 1, + "environment_additions": {}, + "expected_stderr": "Coordinate receipt mismatch", + "actual_stderr": "Traceback (most recent call last):\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 42, in \n require(actual == expected, 'Coordinate receipt mismatch')\n ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/var/folders/ph/5swjdlqd3997q5j1y6zvmty80000gp/T/e8-independent-controls-to6sqrg7/package/verify.py\", line 14, in require\n raise ValueError(message)\nValueError: Coordinate receipt mismatch\n" + } + ], + "scope": "Independent finite premises and boundary controls. Not a formal proof of every factorization." +} diff --git a/research/e8-small-redundancy/review/independent_controls.py b/research/e8-small-redundancy/review/independent_controls.py new file mode 100644 index 0000000000..23d1807c9a --- /dev/null +++ b/research/e8-small-redundancy/review/independent_controls.py @@ -0,0 +1,177 @@ +"""Check proof premises and rejection controls without package imports.""" + +import gzip +import hashlib +import json +import os +import shutil +import subprocess +import sys +import tempfile +from collections import Counter +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PACKAGE = HERE.parents[1] / "early-remainder-audit/packages/e8-small-redundancy" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def rank(rows, field=None): + basis = {} + for values in rows: + row = [Fraction(x) for x in values] if field is None else [x % field for x in values] + for pivot, other in sorted(basis.items()): + value = row[pivot] + row = [x - value * y for x, y in zip(row, other)] + if field is not None: + row = [x % field for x in row] + pivot = next((i for i, value in enumerate(row) if value), None) + if pivot is not None: + scale = 1 / row[pivot] if field is None else pow(row[pivot], -1, field) + row = [x * scale for x in row] + if field is not None: + row = [x % field for x in row] + basis[pivot] = row + return len(basis) + + +def bit_basis(words): + pivots = {} + for word in words: + for pivot, row in sorted(pivots.items(), reverse=True): + if (word >> pivot) & 1: + word ^= row + if word: + pivots[word.bit_length() - 1] = word + return list(pivots.values()) + + +def coordinates(simple, vector): + matrix = [[Fraction(simple[j][i]) for j in range(8)] + [Fraction(vector[i])] + for i in range(8)] + for col in range(8): + pivot = next(i for i in range(col, 8) if matrix[i][col]) + matrix[col], matrix[pivot] = matrix[pivot], matrix[col] + scale = matrix[col][col] + matrix[col] = [x / scale for x in matrix[col]] + for row in range(8): + if row != col: + scale = matrix[row][col] + matrix[row] = [x - scale * y for x, y in zip(matrix[row], matrix[col])] + return [row[-1] for row in matrix] + + +roots = json.loads(gzip.decompress((PACKAGE / "inputs/bit-word.json.gz").read_bytes()))["lines"] +simple = json.loads((PACKAGE / "binary/parabolic-results.json").read_text())["simple_roots"] +signed_roots = roots + [[-x for x in row] for row in roots] +require(rank(simple) == 8, "Simple roots must be independent") +for root in signed_roots: + values = coordinates(simple, root) + require(all(x.denominator == 1 for x in values), "Root coordinates must be integral") + require(all(x >= 0 for x in values) or all(x <= 0 for x in values), + "Root coordinates must have one sign") + +kernel = [sum((1 + sum(x * y for x, y in zip(q, r)) // 2) % 2 << j + for j, r in enumerate(roots)) for q in roots] +basis = bit_basis(kernel) +require(len(basis) == 9, "The binary corrector must have rank nine") +code = [0] +for row in basis: + code += [word ^ row for word in code] +require(len(set(code)) == 512, "The code enumeration must be complete") + +coset = [word ^ 1 for word in code] +require(1 not in code, "The coordinate unit must lie outside the code") +histogram = Counter() +for word in coset: + support = [roots[j] for j in range(120) if (word >> j) & 1] + # A modular full-rank witness proves rational full rank. + value = 8 if rank(support, 101) == 8 else rank(support) + histogram[value] += 1 +require(histogram == {1: 1, 7: 1, 8: 510}, "The unit coset must attain defect eight") +require(rank([roots[j] for j in range(120) if ((kernel[0] ^ 1) >> j) & 1]) == 7, + "A root-row support loses full rank when its own root is removed") +linear_kernel = [sum((sum(x * y for x, y in zip(q, r)) // 2) % 2 << j + for j, r in enumerate(roots)) for q in roots] +require(len(bit_basis(linear_kernel)) == 8, "The affine constant changes the matrix rank") + +controls = [] +with tempfile.TemporaryDirectory(prefix="e8-independent-controls-") as temporary: + copy = Path(temporary) / "package" + shutil.copytree(PACKAGE, copy, ignore=shutil.ignore_patterns("__pycache__")) + + def rejected(name, command, expected, extra_env=None): + completed = subprocess.run(command, capture_output=True, text=True, timeout=300, + env={**os.environ, **(extra_env or {})}) + require(completed.returncode != 0 and expected in completed.stderr, + "Control did not fail at the required check: " + name) + controls.append({"name": name, "command": command, "exit_code": completed.returncode, + "environment_additions": extra_env or {}, + "expected_stderr": expected, "actual_stderr": completed.stderr}) + + path = copy / "inputs/bit-word.json.gz" + original = path.read_bytes() + path.write_bytes(original[:-1] + bytes([original[-1] ^ 1])) + rejected("input_hash_corruption", [sys.executable, "-B", str(copy / "verify.py")], + "Source hash mismatch: inputs/bit-word.json.gz") + path.write_bytes(original) + + bit_word = json.loads(gzip.decompress(original)) + bit_word["lines"] = bit_word["lines"][:-1] + path.write_bytes(gzip.compress(json.dumps(bit_word).encode(), mtime=0)) + rejected("one_root_omitted", [sys.executable, "-B", str(copy / "binary/parabolic_check.py")], + "AssertionError") + path.write_bytes(original) + + bit_word = json.loads(gzip.decompress(original)) + bit_word["lines"][0][0] += 5 + path.write_bytes(gzip.compress(json.dumps(bit_word).encode(), mtime=0)) + manifest_path = copy / "SOURCE-HASHES.json" + manifest = json.loads(manifest_path.read_text()) + manifest["inputs/bit-word.json.gz"] = hashlib.sha256(path.read_bytes()).hexdigest() + manifest_path.write_text(json.dumps(manifest, indent=2) + "\n") + rejected("assertions_active_with_inherited_optimization", + [sys.executable, "-I", "-O", "-B", str(copy / "verify.py")], + "assert all(sum(x*x for x in q) == 4 for q in all_roots)", + {"PYTHONOPTIMIZE": "1"}) + path.write_bytes(original) + manifest["inputs/bit-word.json.gz"] = hashlib.sha256(original).hexdigest() + manifest_path.write_text(json.dumps(manifest, indent=2) + "\n") + + path = copy / "inputs/complex-word.json.gz" + original = path.read_bytes() + complex_word = json.loads(gzip.decompress(original)) + complex_word["ports"][0], complex_word["ports"][1] = complex_word["ports"][1], complex_word["ports"][0] + path.write_bytes(gzip.compress(json.dumps(complex_word).encode(), mtime=0)) + rejected("certificate_port_order_changed", + [sys.executable, "-B", str(copy / "coordinate/coordinate_totals_rigidity.py"), str(path)], + "AssertionError") + path.write_bytes(original) + + name = "coordinate/coordinate_totals_rigidity.json" + path = copy / name + receipt = json.loads(path.read_text()) + receipt["results"][0]["rational_rank"] = 62 + path.write_text(json.dumps(receipt, indent=2) + "\n") + manifest_path = copy / "SOURCE-HASHES.json" + manifest = json.loads(manifest_path.read_text()) + manifest[name] = hashlib.sha256(path.read_bytes()).hexdigest() + manifest_path.write_text(json.dumps(manifest, indent=2) + "\n") + rejected("wrong_receipt_with_updated_manifest", [sys.executable, "-B", str(copy / "verify.py")], + "Coordinate receipt mismatch") + +result = {"status": "PASS", "package": str(PACKAGE), "independent_imports": [], + "signed_root_expansions": 240, "simple_basis_rank": 8, + "root_coordinates_integral_and_one_sign": True, "binary_kernel_rank": len(basis), + "linear_kernel_without_affine_constant_rank": len(bit_basis(linear_kernel)), + "unit_coset_support_rank_histogram": dict(sorted(histogram.items())), + "unit_coset_total_defect": sum((8 - k) * v for k, v in histogram.items()), + "root_row_with_own_root_removed_rank": 7, "rejection_controls": controls, + "scope": "Independent finite premises and boundary controls. Not a formal proof of every factorization."} +(HERE / "independent-controls.json").write_text(json.dumps(result, indent=2) + "\n") +print("PASS_E8_INDEPENDENT_CONTROLS root_expansions=240 coset_words=512 rejected=5") diff --git a/research/e8-small-redundancy/review/verify-command.json b/research/e8-small-redundancy/review/verify-command.json new file mode 100644 index 0000000000..fd9f31429d --- /dev/null +++ b/research/e8-small-redundancy/review/verify-command.json @@ -0,0 +1,12 @@ +{ + "command": [ + "python3", + "-B", + "work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy/verify.py" + ], + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "python": "3.14.7", + "exit_code": 0, + "elapsed_seconds": 13.255030870437622, + "parallelism": "One verifier process; child checks run sequentially; standard library only." +} diff --git a/research/e8-small-redundancy/review/verify-final-command.json b/research/e8-small-redundancy/review/verify-final-command.json new file mode 100644 index 0000000000..fede0dd59b --- /dev/null +++ b/research/e8-small-redundancy/review/verify-final-command.json @@ -0,0 +1,23 @@ +{ + "command": [ + "python3", + "-I", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy/verify.py" + ], + "environment_additions": { + "PYTHONOPTIMIZE": "1", + "OMP_NUM_THREADS": "1", + "OPENBLAS_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "PYTHONDONTWRITEBYTECODE": "1" + }, + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "python": "3.14.7", + "exit_code": 0, + "elapsed_seconds": 12.917542219161987, + "all_package_bytes_unchanged": true, + "files": 30, + "parallelism": "Sequential standard-library checks. Child commands use -E -B so Python environment flags cannot disable inherited assertions." +} diff --git a/research/e8-small-redundancy/review/verify-final.stderr.txt b/research/e8-small-redundancy/review/verify-final.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/e8-small-redundancy/review/verify-final.stdout.txt b/research/e8-small-redundancy/review/verify-final.stdout.txt new file mode 100644 index 0000000000..1b10bf28ba --- /dev/null +++ b/research/e8-small-redundancy/review/verify-final.stdout.txt @@ -0,0 +1,9 @@ +PASS binary/parabolic_check.py +PASS binary/e7_complements.py +PASS binary/eleven_facts.py +PASS binary/independent_structure.py +PASS binary/independent_eleven_facts.py +PASS binary/independent_coordinate_map.py +PASS coordinate/coordinate_totals_rigidity.py +PASS coordinate/rigidity_review_72vars.py +PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa diff --git a/research/e8-small-redundancy/review/verify-isolated-optimized-command.json b/research/e8-small-redundancy/review/verify-isolated-optimized-command.json new file mode 100644 index 0000000000..1c5d3e71ca --- /dev/null +++ b/research/e8-small-redundancy/review/verify-isolated-optimized-command.json @@ -0,0 +1,16 @@ +{ + "command": [ + "python3", + "-I", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-remainder-audit/packages/e8-small-redundancy/verify.py" + ], + "cwd": "/Users/aliromman/Projects/IntegerMultiplicationBounds", + "python": "3.14.7", + "exit_code": 0, + "elapsed_seconds": 20.351598024368286, + "all_package_bytes_unchanged": false, + "files": 30, + "parallelism": "Sequential standard-library checks. Child interpreter commands explicitly omit -O, so inherited assertions remain active." +} diff --git a/research/e8-small-redundancy/review/verify-isolated-optimized.stderr.txt b/research/e8-small-redundancy/review/verify-isolated-optimized.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/e8-small-redundancy/review/verify-isolated-optimized.stdout.txt b/research/e8-small-redundancy/review/verify-isolated-optimized.stdout.txt new file mode 100644 index 0000000000..1b10bf28ba --- /dev/null +++ b/research/e8-small-redundancy/review/verify-isolated-optimized.stdout.txt @@ -0,0 +1,9 @@ +PASS binary/parabolic_check.py +PASS binary/e7_complements.py +PASS binary/eleven_facts.py +PASS binary/independent_structure.py +PASS binary/independent_eleven_facts.py +PASS binary/independent_coordinate_map.py +PASS coordinate/coordinate_totals_rigidity.py +PASS coordinate/rigidity_review_72vars.py +PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa diff --git a/research/e8-small-redundancy/review/verify.stderr.txt b/research/e8-small-redundancy/review/verify.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/e8-small-redundancy/review/verify.stdout.txt b/research/e8-small-redundancy/review/verify.stdout.txt new file mode 100644 index 0000000000..1b10bf28ba --- /dev/null +++ b/research/e8-small-redundancy/review/verify.stdout.txt @@ -0,0 +1,9 @@ +PASS binary/parabolic_check.py +PASS binary/e7_complements.py +PASS binary/eleven_facts.py +PASS binary/independent_structure.py +PASS binary/independent_eleven_facts.py +PASS binary/independent_coordinate_map.py +PASS coordinate/coordinate_totals_rigidity.py +PASS coordinate/rigidity_review_72vars.py +PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa diff --git a/research/e8-small-redundancy/reviews/BINARY-HISTORICAL.md b/research/e8-small-redundancy/reviews/BINARY-HISTORICAL.md new file mode 100644 index 0000000000..982ac83f41 --- /dev/null +++ b/research/e8-small-redundancy/reviews/BINARY-HISTORICAL.md @@ -0,0 +1,77 @@ +# Independent audit of the eleven-centre obstruction + +Reviewed proof: `theory/ELEVEN-PROOF.md`. +SHA-256: `2bc8e531ce6d3d683f760a4208e9be2a061fe15b54bca0034de59c292c17f65e`. + +Result: the proof is valid for its stated fixed binary E8 matrix and scalar +source-reader factorization model. Every factorization with at most eleven +terms has rational source-reader pairing-rank sum at least 72. This is a +computer-assisted proof. It is not a formal Lean verification. + +## Independent finite checks + +The primary checker uses the Hamming coordinates from the pinned word. The +independent checks generate the 120 standard E8 root lines separately and +use a different simple root basis. + +- `independent_structure.py` verifies all eight root-hyperplane cases, all + 511 nonzero codeword support ranks, all required outside support spans, + and the E7 common-neighbor and neighbor-rank facts. +- `independent_eleven_facts.py` verifies the full 512-word outside-weight + histogram, the root inner products, all seven E7 maximal proper flats, + their rank-seven complements, and the maximum proper-flat size of 36. +- `independent_coordinate_map.py` constructs a rational similarity between + the two coordinate systems and checks the image of every one of the 120 + root lines. Thus the independent standard-coordinate checks concern the + same pinned matrix, up to a simultaneous coordinate permutation. + +All three scripts passed. Results are in the corresponding JSON files. +For rank-eight support decisions, modular rank eight is a valid lower bound +on rational rank, hence certifies equality. Lower ranks and required +rank-seven support spans in the structural checker use Fraction arithmetic. +The E7 complement checks establish rank at least seven modulo 101 and rank +at most seven from containment in the E7 hyperplane. + +## Argument review + +The arbitrary-flat reduction is complete: a root span extends to a root +hyperplane; a Weyl transformation moves its normal to the closed dominant +chamber; the roots perpendicular to that normal are generated by exactly +seven simple roots. The corresponding E7 argument covers every proper E7 +root span. Reflection closure is checked by the primary implementation. + +The coset star classification includes centres of rank eight. The proof +therefore does not silently assume that a centre itself is a selected +low-rank vector. Its defect identity also permits omitted centres. + +For independent centres, the small-error lemma uses the full outside-weight +histogram. The earlier D_H classification alone would not suffice here. +The rank-seven sum forces all residual supports into the same E7 hyperplane. +An omitted rank-eight centre contains its normal in the span of its removed +orthogonal roots. Unless that normal is one of those roots, exactly four +roots have nonzero coefficients. Root parity would require four shared +satellite roots, but basis independence permits at most one shared root for +each pair of groups. This gives the stated contradiction. The remaining +normal-root cases give explicit binary dependencies among selected vectors. + +For dependent centres, the three stated lifted-root dual vectors pair only +with their own root and have nonzero self-pairing. They prove the bound on +the number of distinct selected satellite roots. The duplicate count covers +all three pair types. Its only possible defect-17 case forces a rank-one +centre and two rank-eight centres. The repeated root is then isolated in a +rank-eight centre, so its removal has rank seven. This is inconsistent with +the other centre having rank eight. + +The final factor-rank reduction is complete. After zero terms are removed, +Sylvester's inequality leaves only the factor-rank pairs listed in the +proof. Repeated columns can be merged without increasing pairing-rank cost. +For factors of rank (10,10), the ten-dimensional coset bound gives the +termwise pairing-rank argument. For (9,11), the rank-nine side has full +rational source span in every term, and the other side is a basis of an +eleven-dimensional space containing C. The symmetric case is identical. + +## Scope + +This proof does not exclude twelve or more terms. It does not exclude a +change to the matrix, the allowed operations, or the scalar retained-total +model. No positive bound improvement is claimed. diff --git a/research/e8-small-redundancy/reviews/COORDINATE-HISTORICAL.md b/research/e8-small-redundancy/reviews/COORDINATE-HISTORICAL.md new file mode 100644 index 0000000000..647e63a3bb --- /dev/null +++ b/research/e8-small-redundancy/reviews/COORDINATE-HISTORICAL.md @@ -0,0 +1,29 @@ +# Independent review of the coordinate-total rigidity result + +Reviewer: `/root/math_audit/center_lower_bound/rigidity_review`. + +Reviewed files: `coordinate_totals_rigidity.md` and `coordinate_totals_rigidity.py` in this directory. The reviewer found no mathematical gap or counterexample within the stated scope. It checked the full-support lemma, quotient normalization, pairwise-difference argument, common scalar, binary support span, scatter identity, and rowspace bridge. + +The reviewer independently reconstructed all 120 certificate ports. It also built a separate system with 72 variables: nine coordinates for each of eight difference vectors, eight explicit zero-sum constraints, and every pairwise equality at each forbidden port. The main checker instead uses 64 variables in a basis of the zero-sum space and only star-shaped equality constraints at each port. + +The independent system gave these ranks over F_107: + +| Extra normal weight | Rows | Rank | Nullity | +|---|---:|---:|---:| +| 0 | 1016 | 71 | 1 | +| 1 | 1128 | 72 | 0 | +| 3 | 1144 | 72 | 0 | +| 5 | 1112 | 72 | 0 | +| 7 | 1128 | 72 | 0 | + +The reviewer saved `rigidity_review_72vars.py` and ran this command from the task directory: + +``` +python3 -I -B coordinate-totals/rigidity_review_72vars.py ../e8-coupled-retiming/research/e8-coupled-retiming/data/original.json.gz +``` + +The command returned exit code zero. The certificate SHA-256 was `4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa`. The independent script imports no repository module. + +The reviewer confirmed that the four nondegenerate subframe orbits have sizes 8, 56, 56, and 8. It also checked that elimination of the common coefficient function loses no constraints: every port has at least one forbidden coordinate. + +The result concerns exactly nine totals assigned to the nine coordinate hyperplanes, with their span containing the fixed canonical E8 coefficient space. It does not establish a global copy-cost floor for other frame sets, other fitting matrices, or more totals. This review did not run Lean or verify the complete circuit. diff --git a/research/e8-small-redundancy/verify.py b/research/e8-small-redundancy/verify.py new file mode 100644 index 0000000000..1c164da13f --- /dev/null +++ b/research/e8-small-redundancy/verify.py @@ -0,0 +1,48 @@ +"""Replay the finite proof premises in a temporary directory.""" +import hashlib +import json +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent + +def require(condition, message): + if not condition: + raise ValueError(message) + +for name, expected in json.loads((HERE / 'SOURCE-HASHES.json').read_text()).items(): + require(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == expected, + 'Source hash mismatch: ' + name) + +with tempfile.TemporaryDirectory(prefix='e8-small-redundancy-') as temp: + work = Path(temp) / 'package' + shutil.copytree(HERE, work, ignore=shutil.ignore_patterns('__pycache__')) + def run(script, *args): + completed = subprocess.run([sys.executable, '-E', '-B', str(work / script), *args], + cwd=work, capture_output=True, text=True, timeout=300) + require(completed.returncode == 0, script + '\n' + completed.stderr) + print('PASS ' + script, flush=True) + return completed.stdout + for script in ['parabolic_check.py', 'e7_complements.py', 'eleven_facts.py', + 'independent_structure.py', 'independent_eleven_facts.py', + 'independent_coordinate_map.py']: + run('binary/' + script) + for name in ['parabolic-results.json', 'e7-complements.json', 'eleven-facts.json', + 'independent-structure-result.json', 'independent-eleven-facts.json', + 'independent-coordinate-map.json']: + require(json.loads((work / 'binary' / name).read_text()) == + json.loads((HERE / 'binary' / name).read_text()), + 'Receipt mismatch: ' + name) + certificate = str(work / 'inputs/complex-word.json.gz') + actual = json.loads(run('coordinate/coordinate_totals_rigidity.py', certificate)) + expected = json.loads((HERE / 'coordinate/coordinate_totals_rigidity.json').read_text()) + require(actual == expected, 'Coordinate receipt mismatch') + independent = json.loads(run('coordinate/rigidity_review_72vars.py', certificate)) + require(independent['variables'] == 72 and independent['field_prime'] == 107, + 'Independent coordinate model mismatch') + require([x['rank_mod_107'] for x in independent['results']] == [71,72,72,72,72], + 'Independent coordinate ranks mismatch') +print('PASS_E8_SMALL_REDUNDANCY coordinate_rigidity=9 binary_terms<=11 pairing_floor=72 no_new_kappa') diff --git a/research/private-query-concave-range/HANDOFF.md b/research/private-query-concave-range/HANDOFF.md new file mode 100644 index 0000000000..1228715ac3 --- /dev/null +++ b/research/private-query-concave-range/HANDOFF.md @@ -0,0 +1,52 @@ +# Private-query lane handoff + +The new scalar lemma is proved. For `0<=a<=1`, + +`7*9^a+2-8*8^a>2/27`. + +Use the five exact integer inequalities in `PROOF.md`. The derivative +argument gives the bound for the whole real interval. The new verifier +checks the exact premises without floating-point arithmetic. Normal +Python and optimized Python both pass. `RESULT.json`, +`OPTIMIZED-RESULT.json`, and `LOG.json` record those checks and hashes. +An independent reviewer passed the scalar argument, the row reduction, +the chord signs, and all endpoint cases. Its review is in +`independent-review/REVIEW.md`. That review treats the old six premises +as assumptions and does not certify the historical geometry. + +With the six stated historical premises, the private scalar query +optimum is `8*8^(1-b)` for every `0<=b<=1`. The old weighted note only +covers `01`, rank-nine frames for the eight coordinate +queries give a smaller bill. Thus the new upper endpoint is sharp for +this model. There is no new multiplier construction or integer kappa. + +The proof applies to the fixed retained E8 Gram correction and private +scalar frames of ranks one through nine. It does not apply to shared +carriers, native blocks, productive ownership, or unproved changes of +the encoding or controller. Binary invertible source-label changes and +nonzero diagonal source scalings preserve its rank and support premises. + +The exact old input bindings are in `LOG.json`. No historical input was +changed. No old finite suite was replayed. The new exact scalar proof +does not certify the old Gram code or sharp-rank closures. + +This is a useful secondary obstruction. The new proof package is small. +A full independent submission needs the old finite geometry and sharp64 +package, which is much larger. The cyclic lane has more direct expected +value because it supplies a uniform bound for a retained precision +obligation. Keep this proof available for a focused private-query +submission after the cyclic result. + +The parent agent checks the live novelty and publication context. At the +time of this lane, it found no private-query extension in the relevant +new PR bodies. This is not a completed novelty review of all sources. + +Next useful actions: + +1. If this result is selected for publication, select the smallest old + dependency package that proves the six premises. Run its required + submission checks once with clean inputs. +2. Compare a private shared-carrier or productive-owner escape with the + cyclic precision work. The current scalar result closes no such escape. + +Prepared with OpenAI Codex assistance. New work is under Apache-2.0. diff --git a/research/private-query-concave-range/LOG.json b/research/private-query-concave-range/LOG.json new file mode 100644 index 0000000000..cbfc149432 --- /dev/null +++ b/research/private-query-concave-range/LOG.json @@ -0,0 +1,41 @@ +{ + "question": "Does the rank-nine private scalar optimum hold for the full concave exponent range?", + "outcome": "PASS with stated historical premises; 0<=b<=1, strict q>=65,N>=9 gap >2/27.", + "compute_policy": "One CPU; no external compute. No large historical suite.", + "free_disk_KiB_before": 7538552, + "commands": [ + { + "command": "python3 -B work/fresh-research-20261012/private-bound/verify_scalar_lemma.py work/fresh-research-20261012/private-bound/RESULT.json", + "exit_code": 0 + }, + { + "command": "python3 -O -B work/fresh-research-20261012/private-bound/verify_scalar_lemma.py work/fresh-research-20261012/private-bound/OPTIMIZED-RESULT.json", + "exit_code": 0 + } + ], + "historical_evidence_scope": "Inputs are read and hash-bound. Their stored checks are not replayed. The new exact scalar premises are checked separately.", + "historical_source_sha256": { + "work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md": "da037411ecc48265f2a9208ee6deb4e676048662276c783e66e7ec12299cd9ad", + "work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5", + "work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json": "12c977b9f2891a8d664cb8e484afd88e591df8cf688333695dfd715b949cea75", + "work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json": "1c242fd2b12a05f6b1471251f9ef5a2f2335a2230f8524d96ddf9374d51bd0c5", + "work/autonomous-kappa-run/framework/private64-weighted/PROOF.md": "54dae3bf87952431c833fd11f727cd39373ca32bbe9a6c08b2166c79259e53ca", + "work/autonomous-kappa-run/framework/private64-weighted/RESULT.json": "e7699aea101f0462540a5882b74a4eb7ed531e3a1b8ea09e053015f32c93b1a4", + "work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4", + "work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json": "044d97c688a3586bda135683b19d1c14ece8ed459ea252934c7c633aa9ac684b" + }, + "new_artifact_sha256": { + "work/fresh-research-20261012/private-bound/PROOF.md": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "work/fresh-research-20261012/private-bound/verify_scalar_lemma.py": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "work/fresh-research-20261012/private-bound/RESULT.json": "827f0eb647b2cf132319e52e8bce1b76e830afc8f753feb6becdb299e5ae08d5", + "work/fresh-research-20261012/private-bound/OPTIMIZED-RESULT.json": "248de8384c88cc3ed07fcd1322ee2fa046b779df5c8881bf841f1fb366d7feb7", + "work/fresh-research-20261012/private-bound/HANDOFF.md": "b433ccd5a62c5b0721268e9a2c2c682ecef54a5bb7c687a3f6c731defad8752e", + "work/fresh-research-20261012/private-bound/independent-review/REVIEW.md": "be69181f904d4db711081b67eebcc8e3b844ee72ca76aaf463e1c87d769794cc", + "work/fresh-research-20261012/private-bound/independent-review/independent-calculation.json": "92165f890ed1b22fe3d91e11841b00a8e95b366e60244008142e23db91f9f797", + "work/fresh-research-20261012/private-bound/independent-review/independent_calculation.py": "249078959b50932308140a24cce96f557b5f5a164f6e4664694797a9e1ac0b25" + }, + "direction_decision": "Keep as a secondary contribution. Cyclic uniform separation has more direct expected value for a retained precision obligation. This extension has small new proof effort but substantial unpublished prerequisites.", + "seed": null, + "independent_review": "PASS new scalar proof and conditional weighted extension; historical premises are not independently certified.", + "independent_command": "python3 -B work/fresh-research-20261012/private-bound/independent-review/independent_calculation.py" +} diff --git a/research/private-query-concave-range/OPTIMIZED-RESULT.json b/research/private-query-concave-range/OPTIMIZED-RESULT.json new file mode 100644 index 0000000000..6551dfb775 --- /dev/null +++ b/research/private-query-concave-range/OPTIMIZED-RESULT.json @@ -0,0 +1,51 @@ +{ + "status": "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", + "strict_gap_lower": "2/27", + "integer_comparisons": [ + { + "name": "positive_critical_point", + "left": "4782969", + "right": "16777216", + "positive_gap": "11994247" + }, + { + "name": "critical_log_ratio", + "left": "497323236409786642155382248146820840100456150797347717440463976893159497012533375533056", + "right": "685596132412797531053607549485540055753823212621556770516014091704614236087297342176409", + "positive_gap": "188272896003010888898225301338719215653367061824209053075550114811454739074763966643353" + }, + { + "name": "critical_point_below_seven_tenths", + "left": "289110211898114048", + "right": "296148833645101056", + "positive_gap": "7038621746987008" + }, + { + "name": "minimum_coefficient_below_four_ninths", + "left": "16677181699666569", + "right": "18014398509481984", + "positive_gap": "1337216809815415" + }, + { + "name": "power_below_thirteen_thirds", + "left": "123834728448", + "right": "137858491849", + "positive_gap": "14023763401" + } + ], + "chord_at_rank_total_65_query_count_9": [ + 2, + 7 + ], + "assumptions_not_replayed": [ + "Fixed Gram code has rank eight and minimum support 53.", + "Source-frame ranks are one through nine.", + "Rank-seven source capacity is at most 36.", + "Total private frame rank is at least 64.", + "Total-64 feasible profiles have no rank-nine frame.", + "Eight rank-eight coordinate gathers factor the Gram code." + ], + "script_sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "proof_sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "seconds": 0.0004563750699162483 +} diff --git a/research/private-query-concave-range/PROOF.md b/research/private-query-concave-range/PROOF.md new file mode 100644 index 0000000000..7dade06bd5 --- /dev/null +++ b/research/private-query-concave-range/PROOF.md @@ -0,0 +1,133 @@ +# Private scalar query cost for the full concave range + +Result: the saved private scalar optimum extends to every `0<=b<=1`. +The minimum bill is `8*8^(1-b)`. This result gives no new construction +and no new integer kappa. + +## Scope and proof inputs + +Use the fixed retained 112-port E8 Gram correction `G=R R^T/4` and the +fixed binary source labels. In a factorization `G=sum_j u_j f_j`, each +nonzero scalar row has a private source frame of rank `1<=r_j<=9`. +The bill is `sum_j r_j^(1-b)`. + +The saved independent proof supplies the following facts. + +1. `rank(G)=8` and every nonzero row in its code has support at least 53. +2. A source frame of rank at most seven has capacity at most 36. +3. Every factorization has total private source rank at least 64. +4. At total rank 64, every profile that passes the necessary conditions + has maximum rank at most eight. +5. Eight coordinate gathers of rank eight each factor `G`. + +Facts 1, 2, 3 and 5 are in +`work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md`. +Fact 4 is in +`work/autonomous-kappa-run/framework/private64-weighted/PROOF.md` and +has a separate rank-multiplicity check in `independent_max_rank.py` in +that directory. This new proof does not repeat those checks. The old +proof only bounds the weighted bill for `02/27`. + +The ratio of the positive term to the negative term in `F'(a)` is + +`(7*log(9)/(8*log(8)))*(9/8)^a`. + +This ratio strictly increases. Thus `F` has a unique global minimum at + +`a0=log(8*log(8)/(7*log(9)))/log(9/8)`. + +The following five exact integer inequalities give all required bounds. + +```text +9^7 < 8^8 +8^96 < 9^91 +13^10 * 8^7 < 12^10 * 9^7 +9^17 < 8^18 +8^7 * 3^10 < 13^10 +``` + +The first gives `a0>0`. The second gives +`8*log(8)/(7*log(9))<13/12`. The third gives +`13/12<(9/8)^(7/10)`. Hence `a0<7/10`. +The fourth gives `8*log(9/8)/log(9)<4/9`. +The fifth gives `8^(7/10)<13/3`. + +At the critical point, the derivative equation gives + +`F(a0)=2-(8*log(9/8)/log(9))*8^a0` + +`>2-(4/9)*(13/3)=2/27`. + +This proves the inequality on the whole interval. Numerical samples +are not proof inputs. + +## Complete weighted bound + +Remove zero rows. Retain an independent basis of the query rows and +absorb each removed row into the decoder. This preserves `G` and removes +a positive charge. Let `N` be the number of retained rows, `q=sum r_j`, +and `a=1-b`. Then `N>=8` and `0<=a<=1`. + +If `N=8`, the query space equals the eight-dimensional code. Each row +has support at least 53, so each frame has rank at least eight. Thus +`sum r_j^a>=8*8^a`. + +If `q=64`, Fact 4 gives `r_j<=8`. Since `b>=0`, + +`sum r_j^(1-b)=sum r_j*r_j^(-b)>=64*8^(-b)=8*8^a`. + +In every other case, `N>=9` and `q>=65`. Concavity puts each value +`r^a`, for `1<=r<=9`, above its chord from rank one to rank nine: + +`r^a >= A*r+C`, + +where `A=(9^a-1)/8>=0` and `C=1-A>=0`. +Therefore + +`sum r_j^a>=A*q+C*N>=65*A+9*C=7*9^a+2` + +`>8*8^a+2/27`. + +These cases cover every finite factorization in the stated model. The +eight coordinate gathers attain `8*8^a` for every `0<=b<=1`. +For `01`, enlarge each +coordinate-gather frame to rank nine. This gives a valid private bill +`8*9^(1-b)<8*8^(1-b)`. This is an allowed source-frame change, not a new +physical circuit or global recurrence. + +## Value and verification limit + +The extension excludes a weighted-cost escape through redundant private +queries for the full concave range. It separates that obstruction from +the small current complex-saving interval. It does not improve the +current multiplier. The new proof needs five integer comparisons and +elementary calculus. The full submission also needs the substantial +finite geometry and sharp-rank dependencies of the unpublished proof. +The extension alone is small. Its prerequisite package is not small. + +Run `verify_scalar_lemma.py` with a new output path. It checks each integer +inequality, the exact rational margin, and the endpoint algebra. It +imports no historical verifier and uses no floating-point arithmetic. +It verifies the new scalar lemma's finite premises. The hand proof +supplies the real-variable argument. It does not replay the Gram code, +profile screen, or final algebraic closures. + +Prepared with OpenAI Codex assistance. New work is under Apache-2.0. diff --git a/research/private-query-concave-range/README.md b/research/private-query-concave-range/README.md new file mode 100644 index 0000000000..20e921ed76 --- /dev/null +++ b/research/private-query-concave-range/README.md @@ -0,0 +1,99 @@ +# Private-query cost on the full concave range + +For the fixed retained 112-port E8 Gram correction and private source +frames, the saved optimum extends to the whole range `0 <= b <= 1`: +the bill `sum_j r_j^(1-b)` has minimum `8*8^(1-b)`. The new scalar step +is the uniform inequality `7*9^a + 2 - 8*8^a > 2/27` for `0 <= a <= 1`. +It uses five exact integer comparisons and a written derivative argument. +This is a scoped negative result. It supplies no new circuit or kappa. + +Read [PROOF.md](PROOF.md) for the exact model and argument. The result +uses six historical premises: Gram rank eight, minimum support 53, +private frame ranks one through nine, capacity at most 36 below rank +eight, total private rank at least 64 with no rank-nine frame at equality, +and attainment by eight rank-eight coordinate gathers. The proof lists +the rank range as part of its model. Its five numbered facts give the +other premises. The fixed Gram matrix is `G = R R^T/4`, over Q, R or C. +Here `R` is the 112 by 8 matrix `root_lines[8:]` in the retained prototype; +the full prototype has 120 rows. Each private frame is a linear subspace +`F_j` of `F_2^9`, and `r_j = dim_F2(F_j)`. It contains every binary source +label in its query's support and may strictly contain their minimal span. +Scalar queries may be redundant. + +The [historical independent proof](historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md) +and the [sharp-rank proof](historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md) +are included with their finite data and independent checkers. The +[old weighted proof](historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md) +only covers `0 < b <= 1/32`. The new extension preserves that model. +The original historical files remain byte-identical. Their statements +about old publication status and old replay scope are historical. + +The later [one-sided decoder theorem](https://github.com/CrocSwap/integer-mult-bounds/blob/4c32ac3b88d63ad06d2b30e526aa07a12929db36/research/one-sided-decoders-all-m/README.md) +proves a characteristic-zero unweighted floor and a unique cost-64 +decoder in its stated dense-pairing Gram model. It is related work. +The present package retains its own fixed-Gram premise proof and does +not claim a new unweighted floor. A reduction to that later theorem +must check the source-label and cost conventions before it can replace +the historical dependencies. The new scalar inequality and weighted +range are the proposed contribution. + +The eight coordinate gathers attain equality for the full range. +At `b > 1`, enlarging all eight frames to rank nine gives a smaller +bill, so the upper endpoint is exact for this cost law. Shared carriers, +native blocks, productive ownership, changed Gram codes and physical +execution costs are outside the claim. The optional fitting-matrix +extensions in historical notes are not part of this package's new claim. + +From this package directory, with Python 3.10 or later: + +```sh +python3 -B verify.py --build /tmp/private-query-concave-replay +``` + +The build path must not exist. Only the standard library is required. +The final line must be: + +```text +PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS 2/27 1735600 +``` + +The replay checks the scalar inputs in normal and optimized Python, +repeats the independent scalar calculation, and regenerates the geometric +inputs from the pinned root and label data. It checks all 43,435 rank-seven +frames, all 1,735,600 profiles of total rank at most 63, and all 195,666 +rank partitions of total 64. The last check excludes each of the 79,403 +partitions with a rank-nine frame. The runner rejects optimized Python +because the historical checkers use assertions. The standalone scalar +checker works with optimized Python. + +These finite checks do not prove the written capacity arguments, the +two final query-profile contradictions, or the derivative argument. +Those proofs and the historical independent reviews are included. +The run does not repeat fitting-rigidity certificates or any physical +supplier verification. `replayed-receipt.json` and `replay.log` record +the independent cleanup review replay of the current source manifest. +`SOURCE-MANIFEST.json` records exact local +source paths and SHA256 hashes. No current exponent is inferred from +the old cost records. + +The fixed E8 root construction is Jacob Sussman's work, at +[the recorded source commit](https://github.com/jacobalansussman/wht-power-saving-lean/tree/9c94857bbaee886f8649edee0bc2d3c738f9555e). +The data came through @icekylinx's +[PR #531](https://github.com/CrocSwap/integer-mult-bounds/pull/531). +The copied [root and label data](https://github.com/CrocSwap/integer-mult-bounds/blob/e07a8a3f9f79c22113398a0c5dbbc7601f489b3e/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json) +are byte-identical to that Git object. Its +[source notice](https://github.com/CrocSwap/integer-mult-bounds/blob/e07a8a3f9f79c22113398a0c5dbbc7601f489b3e/research/direct-delivery504-global/NOTICE.md) +and [credit record](https://github.com/CrocSwap/integer-mult-bounds/blob/e07a8a3f9f79c22113398a0c5dbbc7601f489b3e/research/direct-delivery504-global/SOURCES.json) +are retained with the copied data. `SOURCE-MANIFEST.json` binds the bytes. +OpenAI Codex and research agents prepared the local +proof and independent checks under the user's direction. No independent +human review is claimed. + +## Open next questions + +Can the weighted range be derived directly from the later one-sided +decoder theorem with the same source-label convention? The first step +is to bind the two root and label coordinate systems and compare the +uncorrected cost definitions. That proof is not supplied here. A physical +shared-carrier method has a different payment rule and needs a separate +analysis before this private-query bound applies. diff --git a/research/private-query-concave-range/RESULT.json b/research/private-query-concave-range/RESULT.json new file mode 100644 index 0000000000..ce9a9222e7 --- /dev/null +++ b/research/private-query-concave-range/RESULT.json @@ -0,0 +1,51 @@ +{ + "status": "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", + "strict_gap_lower": "2/27", + "integer_comparisons": [ + { + "name": "positive_critical_point", + "left": "4782969", + "right": "16777216", + "positive_gap": "11994247" + }, + { + "name": "critical_log_ratio", + "left": "497323236409786642155382248146820840100456150797347717440463976893159497012533375533056", + "right": "685596132412797531053607549485540055753823212621556770516014091704614236087297342176409", + "positive_gap": "188272896003010888898225301338719215653367061824209053075550114811454739074763966643353" + }, + { + "name": "critical_point_below_seven_tenths", + "left": "289110211898114048", + "right": "296148833645101056", + "positive_gap": "7038621746987008" + }, + { + "name": "minimum_coefficient_below_four_ninths", + "left": "16677181699666569", + "right": "18014398509481984", + "positive_gap": "1337216809815415" + }, + { + "name": "power_below_thirteen_thirds", + "left": "123834728448", + "right": "137858491849", + "positive_gap": "14023763401" + } + ], + "chord_at_rank_total_65_query_count_9": [ + 2, + 7 + ], + "assumptions_not_replayed": [ + "Fixed Gram code has rank eight and minimum support 53.", + "Source-frame ranks are one through nine.", + "Rank-seven source capacity is at most 36.", + "Total private frame rank is at least 64.", + "Total-64 feasible profiles have no rank-nine frame.", + "Eight rank-eight coordinate gathers factor the Gram code." + ], + "script_sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "proof_sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "seconds": 0.0003392081707715988 +} diff --git a/research/private-query-concave-range/SOURCE-MANIFEST.json b/research/private-query-concave-range/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..6096c7c27b --- /dev/null +++ b/research/private-query-concave-range/SOURCE-MANIFEST.json @@ -0,0 +1,203 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "original": "work/fresh-research-20261012/private-bound/HANDOFF.md", + "package": "HANDOFF.md", + "sha256": "b433ccd5a62c5b0721268e9a2c2c682ecef54a5bb7c687a3f6c731defad8752e", + "bytes": 2631 + }, + { + "original": "work/fresh-research-20261012/private-bound/LOG.json", + "package": "LOG.json", + "sha256": "c133420d523e3d884cbd0e254595a17d90c9a780844790be261b485b775a9704", + "bytes": 3747 + }, + { + "original": "work/fresh-research-20261012/private-bound/OPTIMIZED-RESULT.json", + "package": "OPTIMIZED-RESULT.json", + "sha256": "248de8384c88cc3ed07fcd1322ee2fa046b779df5c8881bf841f1fb366d7feb7", + "bytes": 1784 + }, + { + "original": "work/fresh-research-20261012/private-bound/PROOF.md", + "package": "PROOF.md", + "sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "bytes": 5001 + }, + { + "original": "work/fresh-research-20261012/private-bound/RESULT.json", + "package": "RESULT.json", + "sha256": "827f0eb647b2cf132319e52e8bce1b76e830afc8f753feb6becdb299e5ae08d5", + "bytes": 1784 + }, + { + "original": "work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "package": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "bytes": 358962 + }, + { + "original": "work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json", + "package": "historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json", + "sha256": "bae45fa968c52e08bda082c82b1fde49aaefeaeec3c201fc56a937da58d75954", + "bytes": 1612 + }, + { + "original": "work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json", + "package": "historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json", + "sha256": "1c242fd2b12a05f6b1471251f9ef5a2f2335a2230f8524d96ddf9374d51bd0c5", + "bytes": 1980 + }, + { + "original": "work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json", + "package": "historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json", + "sha256": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5", + "bytes": 2351 + }, + { + "original": "work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md", + "package": "historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md", + "sha256": "da037411ecc48265f2a9208ee6deb4e676048662276c783e66e7ec12299cd9ad", + "bytes": 12638 + }, + { + "original": "work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json", + "package": "historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json", + "sha256": "12c977b9f2891a8d664cb8e484afd88e591df8cf688333695dfd715b949cea75", + "bytes": 1246 + }, + { + "original": "work/autonomous-kappa-run/framework/private64-weighted/PROOF.md", + "package": "historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md", + "sha256": "54dae3bf87952431c833fd11f727cd39373ca32bbe9a6c08b2166c79259e53ca", + "bytes": 5562 + }, + { + "original": "work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json", + "package": "historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json", + "sha256": "044d97c688a3586bda135683b19d1c14ece8ed459ea252934c7c633aa9ac684b", + "bytes": 1672 + }, + { + "original": "work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "package": "historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "sha256": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4", + "bytes": 5025 + }, + { + "original": "work/autonomous-kappa-run/framework/private64_geometry.py", + "package": "historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "sha256": "dbcfe11a877de04ed64a95f77e0c3ffdaa44d90f34e26d6fdf370e2402c13497", + "bytes": 8942 + }, + { + "original": "work/autonomous-kappa-run/framework/private64_profiles.py", + "package": "historical/work/autonomous-kappa-run/framework/private64_profiles.py", + "sha256": "1e63e4b25d7690a008149489b9c945d129f5465b8d187026f4dc28eef9c1ef88", + "bytes": 3196 + }, + { + "original": "work/p518-next/complex/paired-five/E8-ALL-GATHER.json", + "package": "historical/work/p518-next/complex/paired-five/E8-ALL-GATHER.json", + "sha256": "75b539dadeebddf39a9c4e67d4d8900d1a1105760e546b05bfc056ae8353a209", + "bytes": 59913 + }, + { + "original": "work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.json", + "package": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.json", + "sha256": "a99d7497710565dbfd598b1dd16ea4679b45db9d36761e2fb2f4c3a57429b21e", + "bytes": 17919 + }, + { + "original": "work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.md", + "package": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.md", + "sha256": "5bb5ddb57e750abeca45dbdd2c72cb5b4284ba77b84689cddd5ada4930a9024f", + "bytes": 4029 + }, + { + "original": "work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT-PROOF.md", + "package": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT-PROOF.md", + "sha256": "127899c6f3ce10cada05afa832a96852a6d3bf7d102a0a80016f981ac7601230", + "bytes": 3464 + }, + { + "original": "work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT.json", + "package": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT.json", + "sha256": "9792c58c3b0d3a074d82d2f66ce6dbb88669a3d4a07ec616dd94c26076593ae7", + "bytes": 24711 + }, + { + "original": "work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT-PROOF.md", + "package": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT-PROOF.md", + "sha256": "c869ee34a13ff97122aaaddd5a37a5cbc00987b6d40e20387a4ee5b7fa872c76", + "bytes": 1254 + }, + { + "original": "work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT.json", + "package": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT.json", + "sha256": "9faf48161b26835aa41b40789087b596a748b4aa18c261f536600c11f473ec87", + "bytes": 1130 + }, + { + "original": "work/p518-next/complex/paired-five/E8-NINE-RANK7-QUERY-OBSTRUCTION.md", + "package": "historical/work/p518-next/complex/paired-five/E8-NINE-RANK7-QUERY-OBSTRUCTION.md", + "sha256": "a375ac919af87a27faaeeebfdf9d63495325681d22262f7846578baa19f5392d", + "bytes": 5555 + }, + { + "original": "work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.json", + "package": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.json", + "sha256": "bf29e7f42d440b04cbd5af622cdf4bcaa116c64c936c75855229ff4b2507652b", + "bytes": 6521 + }, + { + "original": "work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md", + "package": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md", + "sha256": "3abbe847857f0afcfa8c9b8f0603d48eefea50c6e176e825e0a3de120ff81565", + "bytes": 4209 + }, + { + "original": "work/p518-next/complex/paired-five/E8-TEN-QUERY-PROFILE-OBSTRUCTION.md", + "package": "historical/work/p518-next/complex/paired-five/E8-TEN-QUERY-PROFILE-OBSTRUCTION.md", + "sha256": "7e6d686a8d3d9514ab660457f4f8f1c8a5662788a9b643b28def3e6dbb561f90", + "bytes": 3541 + }, + { + "original": "work/fresh-research-20261012/private-bound/independent-review/REVIEW.md", + "package": "independent-review/REVIEW.md", + "sha256": "be69181f904d4db711081b67eebcc8e3b844ee72ca76aaf463e1c87d769794cc", + "bytes": 3633 + }, + { + "original": "work/fresh-research-20261012/private-bound/independent-review/independent-calculation.json", + "package": "independent-review/independent-calculation.json", + "sha256": "92165f890ed1b22fe3d91e11841b00a8e95b366e60244008142e23db91f9f797", + "bytes": 1391 + }, + { + "original": "work/fresh-research-20261012/private-bound/independent-review/independent_calculation.py", + "package": "independent-review/independent_calculation.py", + "sha256": "249078959b50932308140a24cce96f557b5f5a164f6e4664694797a9e1ac0b25", + "bytes": 2972 + }, + { + "original": "work/fresh-research-20261012/private-bound/verify_scalar_lemma.py", + "package": "verify_scalar_lemma.py", + "sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "bytes": 2739 + }, + { + "original": "work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md", + "package": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1", + "bytes": 1451 + }, + { + "original": "work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json", + "package": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f", + "bytes": 2592 + } + ] +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md new file mode 100644 index 0000000000..f7a8f861be --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md @@ -0,0 +1,24 @@ +# Attribution and derivative scope + +Prepared for icekylinx with OpenAI GPT-6 Astra assistance; Apache-2.0. +Copyright 2026 icekylinx. Local review and submission packaging used OpenAI Codex. +The new work is the same-partition 504-helper scalar architecture, its frozen +entrance selection, delivery-frame coalescing, literal global allocation, +targeted certificate reuse and complete new finite recount. + +The included Hamming inputs, Gaussian-dyadic Clifford compiler, primitive +scalar routines, rational moment engines and outer assembly descend from the +authors recorded in `SOURCES.json` and `inputs/PR523-ANCESTRY.json`. Original +source notices are retained. In particular, DreamingOfClouds' gauge/kernel +and paid-wrapper files retain their notice crediting Claude Opus 5.5 assistance; +those files are not presented as newly authored work. + +Dugongue's PR522 rank-sector coordinate-total principle was inspected and is +credited as a related idea. This increment does not import its ranksector99 +patch or add its reported gain arithmetically. Higherbeing's PR520 face-packet +geometry helped direct the structural investigation; its code is not copied. +The latest numerical comparison, Rohan Arun's PR527, is a comparison source. + +The reproduction wrapper deliberately separates fresh changed-word/global +checks from reuse of the byte-pinned completed baseline and unchanged bit +operator. Old finite receipts never stand in for the changed local word. diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json new file mode 100644 index 0000000000..78244052aa --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json @@ -0,0 +1,63 @@ +{ + "repository": "https://github.com/CrocSwap/integer-mult-bounds", + "prepared_for": "icekylinx", + "assistance": "OpenAI GPT-6 Astra", + "license": "Apache-2.0", + "baseline": { + "pr": 523, + "author": "icekylinx", + "head": "a900f98be8ff2c09d3292b5112d4731dbd0c8438", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/523", + "role": "112 ordered ports, fixed data controller, completed phase cache and finite baseline allowances." + }, + "retained": [ + { + "pr": 514, + "author": "Dugongue", + "head": "246bfacd4cb4072836ae3147099f548bb728229f", + "role": "Pinned Hamming modules and scalar constructor ancestry; derived from PR507 and PR425/433." + }, + { + "pr": 493, + "author": "eumemic", + "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7", + "role": "Unchanged bit supplier; published histogram repriced, operator not reconstructed." + }, + { + "pr": 484, + "author": "DreamingOfClouds", + "head": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f", + "role": "Attributed shared-donor kernel, entrance-gauge, paid-wrapper and hosting lineage; original Claude Opus assistance notices retained." + } + ], + "related_ideas": [ + { + "pr": 522, + "author": "Dugongue", + "head": "e9f8075b5212e9bddf361097dbb022dcd052e0bb", + "role": "Rank-sector coordinate-total principle inspected and credited. Its ranksector99 patch is not imported; this word completes eight independent retired carriers before the center cut." + }, + { + "pr": 520, + "author": "higherbeing", + "head": "6077fa76950facbce11ec2f04dfbc93493114a44", + "role": "Face-packet delivery geometry and open allocation framing informed the bottleneck investigation; no PR520 implementation is copied." + } + ], + "comparison": { + "pr": 527, + "author": "rohanarun", + "head": "2080903b9e6bd01e3f64cc4c7c62ea1b3af0aa6a", + "kappa": "0.001467289440740487", + "role": "Latest comparable numerical PR in the recorded snapshot; comparison only." + }, + "new_contribution": "Same-partition direct output loading and two-half face delivery with 504 helpers; 72 compatible gauges and 80 exact kernel pivots; body frame coalescing; literal pure-pattern whole-owner allocation; fresh finite global invoice and exact kappa.", + "ancestry_file": "inputs/PR523-ANCESTRY.json", + "comparison_at_submission": { + "pr": 529, + "author": "chafreaky", + "head": "05fc7e332651a41860add3c217cd6f6e88758003", + "kappa": "0.001469603966017302", + "role": "Comparison only; no code or proof imported." + } +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json new file mode 100644 index 0000000000..9efe30ee10 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json @@ -0,0 +1,21364 @@ +{ + "status": "PASS_STRUCTURAL_PACKET_PROTOTYPE_NOT_A_NEW_SUPPLIER", + "source_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "binary_address_dimension": 9, + "binary_gram_rank": 9, + "binary_ports": [ + 1, + 7, + 25, + 31, + 121, + 127, + 97, + 103, + 13, + 405, + 395, + 19, + 491, + 115, + 109, + 501, + 2, + 412, + 388, + 26, + 484, + 122, + 98, + 508, + 400, + 8, + 14, + 406, + 104, + 496, + 502, + 110, + 208, + 336, + 342, + 214, + 296, + 168, + 174, + 302, + 348, + 196, + 220, + 324, + 186, + 290, + 314, + 162, + 341, + 203, + 213, + 331, + 179, + 301, + 307, + 173, + 185, + 289, + 295, + 191, + 313, + 161, + 167, + 319, + 32, + 448, + 454, + 38, + 472, + 56, + 62, + 478, + 460, + 84, + 74, + 466, + 44, + 436, + 426, + 50, + 453, + 91, + 67, + 477, + 37, + 443, + 419, + 61, + 73, + 465, + 471, + 79, + 425, + 49, + 55, + 431, + 265, + 137, + 143, + 271, + 233, + 361, + 367, + 239, + 155, + 259, + 283, + 131, + 379, + 227, + 251, + 355, + 148, + 266, + 276, + 138, + 372, + 234, + 244, + 362 + ], + "root_lines": [ + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 1, + 1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + 1, + -1, + 0, + 1, + 0, + 0, + 1 + ], + [ + 0, + 1, + -1, + 0, + 1, + 0, + 0, + -1 + ], + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0 + ], + [ + 1, + 0, + 1, + 0, + 1, + 0, + -1, + 0 + ], + [ + 1, + 0, + 1, + 0, + -1, + 0, + 1, + 0 + ], + [ + 1, + 0, + 1, + 0, + -1, + 0, + -1, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + 1, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + -1, + 0 + ], + [ + 1, + 0, + -1, + 0, + -1, + 0, + 1, + 0 + ], + [ + 1, + 0, + -1, + 0, + -1, + 0, + -1, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 1, + -1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + -1, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + 1, + -1 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1 + ], + [ + 1, + -1, + 0, + 0, + 0, + 0, + -1, + -1 + ], + [ + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + -1, + 1, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0 + ], + [ + 1, + -1, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 1, + -1, + 0, + 0, + -1, + 1, + 0, + 0 + ], + [ + 1, + -1, + 0, + 0, + -1, + -1, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1 + ], + [ + 1, + 0, + 1, + 0, + 0, + 1, + 0, + -1 + ], + [ + 1, + 0, + 1, + 0, + 0, + -1, + 0, + 1 + ], + [ + 1, + 0, + 1, + 0, + 0, + -1, + 0, + -1 + ], + [ + 1, + 0, + -1, + 0, + 0, + 1, + 0, + 1 + ], + [ + 1, + 0, + -1, + 0, + 0, + 1, + 0, + -1 + ], + [ + 1, + 0, + -1, + 0, + 0, + -1, + 0, + 1 + ], + [ + 1, + 0, + -1, + 0, + 0, + -1, + 0, + -1 + ], + [ + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + -1, + 1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + -1, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1, + -1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + -1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1 + ], + [ + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 1, + -1, + 0, + 0, + -1 + ], + [ + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + -1, + 1, + 0, + 0, + -1 + ], + [ + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + -1, + -1, + 0, + 0, + -1 + ], + [ + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + 1, + 1, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + 1, + -1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + 1, + -1, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + -1, + 1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + -1, + 1, + 0, + -1, + 0 + ], + [ + 0, + 1, + 0, + -1, + -1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 0, + -1, + -1, + 0, + -1, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + -1, + 1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + -1, + -1 + ], + [ + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + -1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + -1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + -1, + -1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + -1 + ], + [ + 0, + 1, + 0, + 1, + 0, + -1, + 0, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + -1, + 0, + -1 + ], + [ + 0, + 1, + 0, + -1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 1, + 0, + -1, + 0, + 1, + 0, + -1 + ], + [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 1 + ], + [ + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1 + ], + [ + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 1, + -1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + -1, + 1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + -1, + -1, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 1, + -1, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + -1, + 1, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + -1, + -1, + 0 + ] + ], + "binary_gram_identity": "p_s dot p_t = 1 + (root_s dot root_t / 2) mod 2", + "modules": [ + { + "block": [ + 0, + 1, + 2, + 3 + ], + "source_lines": [ + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 1, + 4, + 5 + ], + "source_lines": [ + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 1, + 6, + 7 + ], + "source_lines": [ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 2, + 4, + 6 + ], + "source_lines": [ + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 2, + 5, + 7 + ], + "source_lines": [ + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 3, + 4, + 7 + ], + "source_lines": [ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 0, + 3, + 5, + 6 + ], + "source_lines": [ + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 1, + 2, + 4, + 7 + ], + "source_lines": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 1, + 2, + 5, + 6 + ], + "source_lines": [ + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 1, + 3, + 4, + 6 + ], + "source_lines": [ + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 1, + 3, + 5, + 7 + ], + "source_lines": [ + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 2, + 3, + 4, + 5 + ], + "source_lines": [ + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 2, + 3, + 6, + 7 + ], + "source_lines": [ + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + }, + { + "block": [ + 4, + 5, + 6, + 7 + ], + "source_lines": [ + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "packets": 12, + "pair_butterflies": 12, + "packet_additions": 52, + "live_source_registers_borrowed": 8, + "helper_registers": 16, + "total_source_and_helper_registers": 24, + "retired_register_clean_rank": 8, + "independent_pair_branch_comparison_helpers": 48, + "comparison_scope": "48 is a specified independent two-input-form implementation, not the helper count of the current r783 supplier.", + "frame_rank_counts": { + "1": 16, + "2": 24, + "3": 12 + }, + "all_dirty_columns_forward_and_inverse_transpose": 36, + "compensator_omission_rejected": true, + "scope": "A 12-output packet factory and probe sinks. Not a complete 120-port supplier or global frame schedule." + } + ], + "signed_packets": 168, + "full_target_decomposition_columns": 120, + "full_target_decomposition_entries": 14400, + "program_sha256": "d833ae0390d165d7da0c639a3c7aeb77156c2ddb52447087cb49b9d03b19e9b9", + "decomposition": [ + { + "target": 0, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 1, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 2, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 3, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 4, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 5, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 6, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 7, + "cross_block_packets": [], + "side_support": 56 + }, + { + "target": 8, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 9, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 10, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 11, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 12, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 13, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 14, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 15, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 16, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 17, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 18, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 19, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 20, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 21, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 22, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 23, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 24, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 25, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 26, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 27, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 28, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 29, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 30, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 31, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 32, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 33, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 34, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 35, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 36, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 37, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 38, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 39, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 40, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 41, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 42, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 43, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 44, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 45, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 46, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 47, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 48, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 49, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 50, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 51, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 52, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 53, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 54, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 55, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 56, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 57, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 58, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 59, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 60, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 61, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 62, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 63, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 64, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 65, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 66, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 67, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 68, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 69, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 70, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 71, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 1 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 2 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 2 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 72, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 73, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 74, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 75, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 76, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 77, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 78, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 79, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 80, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 81, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 82, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 83, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 84, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 85, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 86, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 87, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 88, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 89, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 90, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 91, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 92, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 93, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 94, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 95, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 6, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 96, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 97, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 98, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 99, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 100, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 101, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 102, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 103, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 2, + 4 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 2, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 4, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 4 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 2, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 104, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 105, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 106, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 107, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 108, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 109, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 110, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 111, + "cross_block_packets": [ + { + "source_block": [ + 1, + 2, + 4, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 1, + 7 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 1, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 1, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 7 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 3, + 5, + 6 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 112, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 113, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 114, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 115, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + } + ], + "side_support": 56 + }, + { + "target": 116, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 117, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": -1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 118, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": 1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": -1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + }, + { + "target": 119, + "cross_block_packets": [ + { + "source_block": [ + 0, + 2, + 4, + 6 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 6, + 7 + ], + "pair": [ + 0, + 6 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 1, + 4, + 5 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 2, + 5, + 7 + ], + "pair": [ + 0, + 5 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 2, + 5, + 6 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 4, + 5, + 6, + 7 + ], + "pair": [ + 5, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 0, + 1, + 2, + 3 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 0, + 3, + 4, + 7 + ], + "pair": [ + 0, + 3 + ], + "epsilon": -1, + "coefficient": "-1/2" + }, + { + "source_block": [ + 1, + 3, + 4, + 6 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 6, + 7 + ], + "pair": [ + 3, + 6 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 2, + 3, + 4, + 5 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + }, + { + "source_block": [ + 1, + 3, + 5, + 7 + ], + "pair": [ + 3, + 5 + ], + "epsilon": 1, + "coefficient": "1/2" + } + ], + "side_support": 56 + } + ], + "remaining": [ + "Joint scheduling and charging of all packet fan-outs and target accumulations", + "Forming all eight centers from the available mixed source basis without an uncharged restore", + "Full 120-port arbitrary-dirt forward/backward program and restored work stocks", + "Exact complex adapters and global phases; finite invoice; two independent prices and outer assembly" + ], + "no_new_coarse_b_or_kappa_claim": true +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json new file mode 100644 index 0000000000..f2cb8fec6c --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json @@ -0,0 +1,66 @@ +{ + "status": "PASS_EXACT_PROFILE_REDUCTION_TO_TWO_ALGEBRAIC_CASES", + "budget": 63, + "source_capacity_upper_bounds": [ + 0, + 1, + 2, + 4, + 8, + 12, + 20, + 36, + 64, + 112 + ], + "generalized_support_lower_bounds": [ + 0, + 53, + 76, + 92, + 100, + 106, + 109, + 111, + 112 + ], + "profile_counts": { + "all": 1735600, + "row_rank": 11440, + "column_incidence": 1041782, + "generalized_support": 682363, + "average_union": 11, + "short_root_pair": 2 + }, + "survivors": [ + [ + 1, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ] + ], + "independent_generating_function_count": 1735600, + "average_union_argument": "For m query supports on 112 ports with incidence at most I, the mean union of a random k-subset is at most 112 minus ((112-r)*C(m-t,k)+r*C(m-t-1,k))/C(m,k), where I=112*t+r. The coverage function is concave in port multiplicity. Every k-subset intersects the rank-eight code in dimension at least k+8-N.", + "remaining_obligations": "The nine-rank-seven simplex case and the rank-one/rank-six/eight-rank-seven case need their separate exact geometric proofs. This script does not prove those closures.", + "scope": "Fixed current E8 code and SOURCE encoding, independent scalar query rows, private frame cost. This is a necessary profile screen, not a circuit or kappa improvement.", + "seconds": 1.2241597496904433, + "checker_sha256": "fdacca0e47414b0f5ba8fa714167e19c6e48111e6fc8f1288963fb9da0a497dd" +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json new file mode 100644 index 0000000000..2bcf205322 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json @@ -0,0 +1,18 @@ +{ + "status": "PASS_FINAL_BINDING_AFTER_METADATA_PROMOTION_AND_ASSERTION_GUARDS", + "scope": "The proof review and exact data did not change. Three finite checkers now reject Python optimization. The root clean replay checks the guarded checkers and three input mutants.", + "source_bindings": { + "work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.json": "bf29e7f42d440b04cbd5af622cdf4bcaa116c64c936c75855229ff4b2507652b", + "work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md": "3abbe847857f0afcfa8c9b8f0603d48eefea50c6e176e825e0a3de120ff81565", + "work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64-PENDING.json": "fb6bba41b344bd779568d61242b417509fb290b3343b4c44a4ace74f1380798d", + "work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md": "da037411ecc48265f2a9208ee6deb4e676048662276c783e66e7ec12299cd9ad", + "work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5", + "work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json": "12c977b9f2891a8d664cb8e484afd88e591df8cf688333695dfd715b949cea75", + "work/autonomous-kappa-run/framework/PRIVATE64-COMMANDS.json": "d79aaaeb78c62eece5d634de9dd309d3078c4f5126dc6f8d4aa332f5f3cdae24", + "work/autonomous-kappa-run/framework/PRIVATE64-SOURCE-BINDING.json": "d0bbfb65a4f02ff6bac0e8ac79b880f89a6fae524221afb587cd3e12cebac278", + "work/autonomous-kappa-run/framework/private64_geometry.py": "dbcfe11a877de04ed64a95f77e0c3ffdaa44d90f34e26d6fdf370e2402c13497", + "work/autonomous-kappa-run/framework/private64_profiles.py": "1e63e4b25d7690a008149489b9c945d129f5465b8d187026f4dc28eef9c1ef88", + "work/autonomous-kappa-run/framework/replay_private64_clean.py": "dc5787baef81bbec6f8c2c19c11c8223f0b92d88f4414807b60858411180a608", + "work/autonomous-kappa-run/framework/private64-clean-root/ROOT-CLEAN-REPLAY.json": "18f73183d343d0b13729c2102ada9b3a6d199e7e62222707edbbbb7f7d3aa5f3" + } +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json new file mode 100644 index 0000000000..e03cb7c91a --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json @@ -0,0 +1,106 @@ +{ + "status": "PASS_INDEPENDENT_PRIVATE64_GEOMETRIC_INPUTS", + "generalized_support_bounds": [ + 53, + 76, + 92, + 100, + 106, + 109, + 111, + 112 + ], + "zero_root_maxima": [ + 0, + 1, + 3, + 6, + 12, + 20, + 36, + 63, + 120 + ], + "fundamental_support_counts": [ + 98, + 92, + 104, + 83, + 57, + 106, + 97, + 78 + ], + "quadratic_ones": 120, + "quadratic_gauss_sum": 16, + "symplectic_pairs": [ + [ + 128, + 1 + ], + [ + 193, + 131 + ], + [ + 227, + 199 + ], + [ + 247, + 239 + ] + ], + "arf_invariant": 0, + "analytic_source_capacities": [ + 0, + 1, + 2, + 4, + 8, + 12, + 20, + 36, + 64, + 112 + ], + "attaining_private_coordinate_frame_ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "negative_control": "Complementing the quadratic sign produces an affine four-space with sixteen ones; the positive-Gauss hypothesis is necessary.", + "root_nonself_hyperplanes_checked": 120, + "rank7_planes": 43435, + "rank7_histogram": { + "26": 10752, + "22": 3584, + "34": 3584, + "30": 10752, + "24": 3752, + "28": 6416, + "32": 3549, + "20": 336, + "36": 448, + "0": 255, + "16": 7 + }, + "maximum_root_intersection_rank7": 32, + "maximum_rank7_intersection_when_self_port_present": 21, + "maximum_rank7_pair_union": 68, + "large_pair_checks": 1806336, + "nonorthogonal_root_planes": 3360, + "orthogonal_root_planes": 3780, + "analytic_rank5_rank6_bounds_require_written_coisotropic_argument": true, + "source_sha256": { + "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/p518-next/complex/paired-five/E8-ALL-GATHER.json": "75b539dadeebddf39a9c4e67d4d8900d1a1105760e546b05bfc056ae8353a209" + }, + "seconds": 0.6259060832671821, + "scope": "Exact chamber, quadratic, complete rank7 and simplex-model prerequisites. Uniform affine rank5/rank6 capacities and both algebraic query closures are supplied by the independent written audit. No scalar-private theorem is inferred solely from this finite receipt." +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..eb253efce5 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md @@ -0,0 +1,230 @@ +# Independent audit of the private scalar query optimum + +Result: PASS in the stated model. For the fixed retained 112-port E8 +matrix `G=R R^T/4` and its fixed binary source encoding, the minimum sum +of private scalar query-frame dimensions is exactly 64. Redundant query +rows do not reduce that minimum over Q, R or C. This is a finite algebraic +result. It supplies no new circuit or exponent saving. + +The contract is explicit. In a factorization `G=sum_j u_j f_j`, each query +row f_j has a binary frame F_j that contains every source port in its +support. Cost is `sum_j dim(F_j)`. This becomes a physical copy-cost bound +only if the private transfer pays at least that dimension for each query. +Shared carriers, native blocks, productive ownership and a changed source +encoding or controller are outside this contract. + +## Independent exact coverage + +The checker imports no producer verifier. It reconstructs chamber +coefficients from the inverse simple-root matrix. It checks integer one-sign +root expansions, all simple reflection images, the 256 simple subsets and +all fundamental support counts. It recovers the quadratic indicator from +the literal 120 labels with a Boolean transform. It checks all 256 values, +its nonsingular polar form, a symplectic basis and positive Gauss sum 16. +It checks every one of the 120 root hyperplane quotients. + +A separate projective two-plane enumeration covers all 43,435 rank-seven +frames. It checks every intersection with all 120 root supports. The +maximum is 32; if the root's self port is present, the maximum is 21. +All 1,806,336 large ordered frame-pair unions have size at most 66. The +uniform rank-seven pair-union bound is 68. + +The profile checker uses rank multiplicities, descending from rank nine +to rank one. It differs from the producer's nondecreasing-prefix recursion. +It covers all 1,735,600 profiles of total cost at most 63 and reproduces +all rejection counts. It leaves exactly the two stated profiles. It also +checks discrete concavity for every `1<=k<=m<=63`. + +The rank-five and rank-six capacities use the uniform argument below. +No second 3,309,747-frame census is claimed. The original census remains +separate evidence. A negative control complements the quadratic sign and +finds an affine four-space with 16 ones, so the positive-sign premise is +necessary for the capacity of twelve. + +## Uniform source capacities + +The full binary source set is the one-set of an affine quadratic function +q in eight dimensions. Its polar form B is nonsingular and its full +character sum is +16. A rank-r frame has either no odd labels or an affine +odd slice of dimension r-1. + +Let a slice have direction L of dimension t, with `4<=t<=7`. Its polar +rank is at least `2t-8`. In the minimum-rank case, put +`A=L intersection L^perp`. Then `dim(A)=8-t` and `L=A^perp`. +The pairing map from `V/L` to `A*` is an isomorphism. Exactly one coset +of L has constant quadratic values along A. The character sum on every +other coset is zero, because translation by a radical vector cancels it. +The sum over all cosets is +16. Thus the one nonzero coset sum is +16, +not -16. This argument retains the constant term of an affine translation. + +All higher polar ranks are at least `2t-8+2`. The character-sum magnitude +is at most `2^(t-rank/2)`. The maximum one-counts at t=4,5,6 are therefore +12,20,36. At t=7 only the minimum-rank branch is possible; its maximum +one-count is 64. Lower dimensions use the elementary point count. This +gives retained frame capacities + +`[0,1,2,4,8,12,20,36,64,112]`. + +Fix a root label p. Its nonself support is the one-set in the seven-dimensional +hyperplane `p^perp` inside odd parity. Exact checks give polar rank six, +constant radical of dimension one and character sum +16. Its quotient is +a six-dimensional quadratic space with character sum +8 and 28 ones. +An affine six-slice that excludes the radical projects onto that full +quotient and has 28 ones. A six-slice that contains the radical projects +onto a five-slice. The coisotropic argument in dimension six bounds that +five-slice by 16 ones, doubled to 32. Smaller slices have at most 32 points. +Thus a rank-seven source frame contained in `p^perp` meets the root support +in at most 32 points. Otherwise its nonself intersection has frame rank at +most six, and has at most 20 points; one self port raises that to at most 21. +Rank-six frames have total source capacity at most 20. + +## Code support and the profile screen + +The finite chamber argument applies to all real coefficient subspaces. +Choose a generic vector in the subspace so that its zero roots are exactly +the common zero roots. A maximum over its finite reflection orbit puts it +in a chamber. Its zero roots lie in the span of the simple roots with zero +pairing. This span has rank at most the codimension of the coefficient +subspace. The independently checked subset maxima are +`[0,1,3,6,12,20,36,63,120]`. + +The unique fundamental direction with full support 57 is a root direction. +Every other active fundamental direction has full support at least 78. +Thus a real non-root query has retained support at least 70. Root directions +have retained support 53 or 56. For complex coefficients, common zeros equal +the common zeros of the real span of real and imaginary parts. That real +dimension is at least the complex dimension. The code support lower bounds +are therefore + +`[53,76,92,100,106,109,111,112]`. + +Drop zero and dependent query rows, and absorb their coefficients into the +decoder columns. This does not increase source frame cost. The remaining +N queries are independent and span a space U containing the eight-dimensional +Gram code W. Every k-query subset has intersection with W of dimension at +least `k+8-N`. Its support union must meet the corresponding code bound. + +Every correction column is nonzero, and the 112 columns are pairwise +nonproportional. The exact identity `R^T R=56I` and distinct root lines prove +this. At most N columns have query incidence one. All others need incidence +at least two. Total query incidence is consequently at least `224-N`. + +For m selected rows, a port occurring x times is covered in a random +k-subset with probability +`g(x)=1-choose(m-x,k)/choose(m,k)`. +Its successive increments are nonnegative and decrease. An exchange of +incidence from a larger multiplicity to a smaller one can only increase +the sum of g. The maximum mean union at total incidence `I=112t+r` is + +`112-((112-r)choose(m-t,k)+r choose(m-t-1,k))/choose(m,k)`. + +Capacities give an upper bound on I. Since g is nondecreasing, that upper +bound is valid even when the actual incidence is smaller. Apply the bound +to the m smallest frames, since every k-subset there is still a subset of +the independent query basis. This proves the average test used in both +enumerations. It is not a heuristic assumption about disjoint supports. + +For N=9, a pair of queries intersects W nontrivially. Ranks at most six +and seven have union size at most 56, so such a code vector is a root +direction. Their root intersections cover at most `20+32=52` support ports, +fewer than the minimum 53. This excludes the additional short-pair cases. +The two surviving profiles are nine sevens and one one, one six, eight sevens. + +## Nine rank-seven queries + +No query lies in W, since its support has size at most 36. The quotient +`U/W` has dimension one. Scale the nine queries to have the same quotient +image. Their eight differences from one query form a basis of W. Every +pair difference has support at most 68. A complex query with independent +real and imaginary coefficient directions would have support at least 76; +a real non-root direction would have support at least 70. Each difference +is therefore a complex scalar times a real root. + +Three noncollinear differences lie in a real root plane. The exact norm +equation permits no third line for an orthogonal pair and precisely the +A2 third line for a nonorthogonal pair. Its coefficients force all scales +to agree up to root orientation. Dividing by one common nonzero complex +scalar gives nine real points whose pair differences are norm-four roots. +They form a regular eight-dimensional simplex. + +The eight edge labels in a star are orthonormal over F2. Their norm-one +orthogonal complement gives the exact label model +`p_ab=J+e_a+e_b` in nine coordinates. The star at j spans the hyperplane +with coordinate j zero. Every nonincident edge label lies outside it. +The removed coordinate root lines are pairwise orthogonal, so their +simplex edges form a matching of at most four edges. Every star retains +at least seven independent labels; some star retains all eight. + +A rank-seven frame at that vertex misses a retained incident port. At this +port, simplex query values have two endpoint values and a common value for +the other seven vertices. Relative endpoint offsets are nonzero opposites. +If one endpoint query is zero, all other eight query values are nonzero. +The missed port is outside its own frame and inside every other frame. + +At each of the seven nonendpoint vertices, this port is outside the full +star span. A frame containing it cannot also contain all seven retained +incident star labels. Each such vertex therefore has another missed port +with the same separating property. At least eight vertices are forced. +For each forced port choose a functional that kills its own frame and +has value one on that port. It kills all other forced ports. They are +independent. If eight vertices are forced, the remaining frame contains +eight independent ports; if nine are forced, every frame contains eight. +Both contradict frame rank seven. This closes the nine-query case. + +## One rank-one, one rank-six and eight rank-seven queries + +For each rank-seven query, its triple with the first two rows intersects W. +No pair in the triple can contain a nonzero code vector: a pair with the +singleton has support below 53, and the six/seven pair has the short-root +contradiction above. Thus the triple intersection is one-dimensional and +uses all three rows with nonzero coefficients. The eight resulting code +vectors are independent because each has a nonzero coefficient of its own +rank-seven row and none of the other seven such rows. + +Each vector has support at most `1+20+36=57`, so it is a root direction. +The three frames meet its root support in at most `1+20+32=53` points. +An omitted axis-root direction has support 56 and is impossible. Each +vector is a retained root direction with support exactly 53. Equality +forces disjoint intersections of sizes 1,20,32. + +Its self port has binary norm one. If that port belongs to a rank-six +frame, the other nonself ports lie in its rank-five orthogonal subframe; +the intersection is at most `1+12=13`. In a rank-seven frame it is at most +`1+20=21`. Neither can attain the required twenty or 32. Hence the self +port must be the singleton query's port. All eight independent code vectors +are then multiples of that same root direction, a contradiction. This +closes the ten-query case. + +## Attainment, extensions and verification limits + +Both cases are impossible, so total private frame rank at most 63 is +impossible. The eight coordinate gathers have frame ranks eight each. +They factor G with decoder R/4 and gather R^T. Their total 64 attains the +lower bound. The independent checker reconstructs all eight support ranks. + +The published combined note also uses previously reviewed fitting rigidity +to allow other minimal rank-nine binary factors and rank-eight scalar +fitting matrices. Invertible binary changes preserve frame dimensions; +nonzero diagonal scalar input changes preserve all supports. Those +implications are valid. Their separate finite rigidity certificates were +read and remain cited dependencies; this audit does not claim another +full replay of those certificates. The new closures themselves require +only the fixed current G and source labels. + +This is a hand proof with exact finite checks, not a Lean proof of the +complete multiplication theorem. No initializer, shared-carrier execution, +native block or productive source interface has been supplied. There is +no new kappa value, runtime measurement or PR claim. + +Run the two standard-library checks with assertions enabled: + +```sh +venv/bin/python -B framework/private64_geometry.py . framework/PRIVATE64-GEOMETRY.json +venv/bin/python -B framework/private64_profiles.py . framework/PRIVATE64-PROFILES.json +``` + +Both passed. Commands, exit codes and hashes are in `PRIVATE64-COMMANDS.json`. +Reviewed source hashes are in `PRIVATE64-SOURCE-BINDING.json`. Existing +failed exploratory bounds and the weaker historical q57 screen stay saved. + +Prepared with OpenAI Codex assistance. diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json new file mode 100644 index 0000000000..149f0de8e8 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json @@ -0,0 +1,44 @@ +{ + "status": "PASS_INDEPENDENT_PRIVATE64_MULTIPLICITY_RECURSION", + "budget": 63, + "profile_counts": { + "all": 1735600, + "row_rank": 11440, + "column_incidence": 1041782, + "generalized_support": 682363, + "average_union": 11, + "short_root_pair": 2 + }, + "survivors": [ + [ + 1, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ] + ], + "discrete_concavity_cases": 2016, + "seconds": 1.6942642917856574, + "source_sha256": { + "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5", + "/Users/aliromman/Documents/Codex/2026-10-10/hello-i-want-to-get-some/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json": "bae45fa968c52e08bda082c82b1fde49aaefeaeec3c201fc56a937da58d75954" + }, + "scope": "Separate rank-multiplicity recursion. The generalized support and balanced-incidence average bounds leave two profiles. Their separate geometric closures and the current scalar-private contract are required before claiming optimum64." +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md new file mode 100644 index 0000000000..8227f76bf9 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md @@ -0,0 +1,131 @@ +# Weighted optimum for private scalar queries + +Result: PASS in the stated private scalar interface. For every +`00`, + +`sum_j r_j^(1-b)=sum_j r_j*r_j^(-b)>=sum_j r_j*8^(-b)=64*8^(-b)`. + +Equality requires every part to equal eight. The literal eight coordinate +gathers and decoder `R/4` attain that profile. Their eight SOURCE support +ranks were reconstructed in the saved geometry check. No other total-64 +profile can reduce the weighted bill. + +## Every larger rank total + +Put `q=sum_j r_j`. Since every `r_j<=9`, + +`sum_j r_j^(1-b)>=q*9^(-b)`. + +Relative to the eight-gather bill, the ratio is at least +`(q/64)*(8/9)^b`. The elementary strict bound `log(9/8)<1/8` and +`exp(-x)>=1-x` imply, for `q>=65` and `0 (65/64)*(1-1/256)=16575/16384 >1`. + +This handles every finite larger profile at once. No increasing-cost +enumeration is needed. At the requested generous ceiling +`B=0.00396314`, the sharper uniform lower ratio is +`5197423959/5120000000 >1`. + +The rank theorem, the exact-total screen and this larger-total bound +prove the stated weighted optimum throughout the current construction's +admitted complex-saving range. They do not prove optimality of the whole +controller or multiplication algorithm. + +## Certified prices and controls + +The independent rational series engine uses 60 logarithm terms, +30 exponential terms and outward rounding to a `10^-60` grid. It imports +no producer price engine. It compares each surviving profile at the +fresh PR569 complex saving +`400657953443603669637/250000000000000000000000` and at B. +All non-reference differences are strictly positive. Equality for `8^8` +is exact. The analytic inequalities above cover the whole interval, +including arbitrarily small positive b; two endpoint samples alone would +not establish that interval statement. + +The controls show why rank sum by itself was insufficient. The unbuilt +profile `1,9^7` also totals 64 and has a strictly lower weighted bill at +the current b. Its singleton row violates the one-dimensional Gram code +support bound. It is not a factorization. Likewise, the unbuilt block +profile `16^4` has a lower bill, but violates the private SOURCE rank-nine +interface. It supplies no block circuit or paid implementation. Both +strict numerical comparisons use exact certified bounds. + +An optimized-Python control rejects before reading inputs. The initial +successful screen is retained. All original private64, frontier and +proposal files remain unchanged. + +Reproduce from the autonomous run directory with a new result path: + +```sh +venv/bin/python -B framework/private64-weighted/check_weighted.py . \ + /tmp/private64-weighted-result.json +``` + +The final run passed, exit zero, in 0.859 seconds. The finite result is +`RESULT.json`; exact command, log hashes and exit status are in +`COMMAND.json`. The proof is not a Lean formalization or an all-size +compiler theorem. + +Prepared with OpenAI Codex assistance. diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json new file mode 100644 index 0000000000..f4f5f3711f --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json @@ -0,0 +1,86 @@ +{ + "status": "PASS_INDEPENDENT_WEIGHTED_RANK_NINE_EXCLUSION", + "partitions": 195666, + "rank_nine_partitions": 79403, + "simple_survivors": [ + { + "profile": [ + 1, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9 + ], + "rejection": { + "reason": "average", + "dimension": 2, + "subset_size": 5, + "selected_rows": 9, + "upper_mean": "455/6", + "required": 76 + } + }, + { + "profile": [ + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 7, + 9 + ], + "rejection": { + "reason": "average", + "dimension": 2, + "subset_size": 4, + "selected_rows": 7, + "upper_mean": "72", + "required": 76 + } + }, + { + "profile": [ + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9 + ], + "rejection": { + "reason": "short_root_pair", + "upper_root_support": 52, + "required": 53 + } + } + ], + "root_pair_omission_survivors": 1, + "relaxed_support_control": [ + 1, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "larger_total_ratio_lower_at_b_1_over_32": "16575/16384", + "geometry_sha256": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5", + "checker_sha256": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4", + "seconds": 0.20951025001704693, + "scope": "Independent necessary-condition audit for total64 profiles with a rank9 query. Prior sharp64 and geometry proofs remain premises. No new circuit or kappa gain." +} diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py new file mode 100644 index 0000000000..cffc9c38aa --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py @@ -0,0 +1,127 @@ +"""Check the only total-64 profiles that can lower the private bill. + +Use rank multiplicities and exact subset means. Do not import the first +checker. The saved geometry proof supplies the support bounds. +Prepared with OpenAI Codex assistance; Apache-2.0. +""" +from fractions import Fraction +from hashlib import sha256 +from math import comb +from pathlib import Path +import json +import sys +import time + +if not __debug__: + raise SystemExit('Run with assertions enabled.') + +ROOT = Path(__file__).resolve().parents[2] +OUT = Path(sys.argv[1]).resolve() +assert not OUT.exists() +START = time.monotonic() +CAP = (0, 1, 2, 4, 8, 12, 20, 36, 64, 112) +SUPPORT = (0, 53, 76, 92, 100, 106, 109, 111, 112) + + +def choose(n, k): + return comb(n, k) if 0 <= k <= n else 0 + + +def reject(profile, bounds=SUPPORT, average=True, root_pair=True): + n = len(profile) + prefix = [0] + for rank in profile: + prefix.append(prefix[-1] + CAP[rank]) + if n < 8: + return {'reason': 'dimension'} + if prefix[-1] < 224 - n: + return {'reason': 'incidence'} + for dimension in range(1, 9): + size = n - 8 + dimension + if prefix[size] < bounds[dimension]: + return {'reason': 'support', 'dimension': dimension} + if average: + for size in range(n - 7, n + 1): + dimension = size - n + 8 + for rows in range(size + 1, n + 1): + quotient, remainder = divmod(prefix[rows], 112) + missing = ((112 - remainder) * choose(rows - quotient, size) + + remainder * choose(rows - quotient - 1, size)) + mean = 112 - Fraction(missing, choose(rows, size)) + if mean < bounds[dimension]: + return {'reason': 'average', 'dimension': dimension, + 'subset_size': size, 'selected_rows': rows, + 'upper_mean': str(mean), + 'required': bounds[dimension]} + if root_pair and n == 9 and profile[0] <= 6 and profile[1] <= 7: + return {'reason': 'short_root_pair', 'upper_root_support': 52, + 'required': 53} + return None + + +count = 0 +rank_nine = 0 +simple_survivors = [] +remaining = [] + + +def enumerate_multiplicities(rank, total, multiplicities): + global count, rank_nine + if rank == 0: + if total: + return + count += 1 + if not multiplicities[9]: + return + rank_nine += 1 + profile = tuple(r for r in range(1, 10) + for _ in range(multiplicities[r])) + if reject(profile, average=False, root_pair=False) is None: + simple_survivors.append(profile) + reason = reject(profile) + assert reason is not None + remaining.append({'profile': profile, 'rejection': reason}) + return + for number in range(total // rank + 1): + multiplicities[rank] = number + enumerate_multiplicities(rank - 1, total - number * rank, + multiplicities) + multiplicities[rank] = 0 + + +enumerate_multiplicities(9, 64, [0] * 10) +assert count == 195666 and rank_nine == 79403 +assert len(simple_survivors) == 3 +assert sum(row['rejection']['reason'] == 'average' for row in remaining) == 2 +assert sum(row['rejection']['reason'] == 'short_root_pair' + for row in remaining) == 1 + +# The root-pair fact is needed. Omitting it leaves one rank-nine profile. +assert sum(reject(p, root_pair=False) is None for p in simple_survivors) == 1 +# The code support fact is needed. This unbuilt profile is cheaper for +# small b but passes the relaxed screen when the first bound is removed. +control = (1,) + (9,) * 7 +relaxed = (0, 1) + SUPPORT[2:] +assert reject(control)['reason'] == 'support' +assert reject(control, bounds=relaxed) is None + +geometry = ROOT / 'framework/PRIVATE64-GEOMETRY.json' +saved = json.loads(geometry.read_text()) +assert tuple(saved['analytic_source_capacities']) == CAP +assert (0,) + tuple(saved['generalized_support_bounds']) == SUPPORT +report = {'status': 'PASS_INDEPENDENT_WEIGHTED_RANK_NINE_EXCLUSION', + 'partitions': count, 'rank_nine_partitions': rank_nine, + 'simple_survivors': remaining, + 'root_pair_omission_survivors': 1, + 'relaxed_support_control': list(control), + 'larger_total_ratio_lower_at_b_1_over_32': + str(Fraction(65, 64) * (1 - Fraction(1, 256))), + 'geometry_sha256': sha256(geometry.read_bytes()).hexdigest(), + 'checker_sha256': sha256(Path(__file__).read_bytes()).hexdigest(), + 'seconds': time.monotonic() - START, + 'scope': 'Independent necessary-condition audit for total64 ' + 'profiles with a rank9 query. Prior sharp64 and geometry ' + 'proofs remain premises. No new circuit or kappa gain.'} +OUT.write_text(json.dumps(report, indent=2) + '\n') +print(json.dumps({k: report[k] for k in ('status', 'partitions', + 'rank_nine_partitions', 'seconds')})) diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_geometry.py b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_geometry.py new file mode 100644 index 0000000000..f551154911 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_geometry.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Check the finite root, quadratic and rank-seven inputs for private rank 64.""" + +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import combinations, product +import json +from pathlib import Path +import sys +import time + +if not __debug__: + raise SystemExit('Run with assertions enabled.') +root,out=map(lambda s:Path(s).resolve(),sys.argv[1:3]) +source=root/'baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json' +data=json.loads(source.read_text());R,P=data['root_lines'],data['binary_ports'];assert len(R)==len(P)==120 +lane=root.parent/'p518-next/complex/paired-five' +chamber_path=lane/'E8-ALL-GATHER.json';chamber=json.loads(chamber_path.read_text()) +started=time.monotonic() +dot=lambda a,b:sum(x*y for x,y in zip(a,b)) +def basis(rows): + pivots={} + for x in rows: + while x: + k=x.bit_length()-1 + if k in pivots:x^=pivots[k] + else:pivots[k]=x;break + return list(pivots.values()) +def inverse(rows): + n=len(rows);a=[list(map(Q,row))+[Q(i==j)for j in range(n)]for i,row in enumerate(rows)] + for j in range(n): + k=next(i for i in range(j,n)if a[i][j]);a[k],a[j]=a[j],a[k] + v=a[j][j];a[j]=[x/v for x in a[j]] + for i in range(n): + if i!=j: + v=a[i][j];a[i]=[x-v*y for x,y in zip(a[i],a[j])] + return [row[n:]for row in a] +assert len(set(P))==120 and all(p.bit_count()%2 for p in P) +assert all(dot(r,r)==4 for r in R) +assert all(dot(R[i],R[j])==0 for i in range(8)for j in range(i)) +assert all((P[i]&P[j]).bit_count()%2==(1+dot(R[i],R[j])//2)%2 for i in range(120)for j in range(120)) + +# Derive chamber coefficients from the simple matrix, rather than use saved +# coefficient lists. The finite reflection argument is in the written audit. +simple=chamber['simple_roots'];inv=inverse(simple) +coefficients=[[sum(Q(row[k])*inv[k][j]for k in range(8))for j in range(8)]for row in R] +assert all(all(x.denominator==1 for x in row)and(all(x>=0 for x in row)or all(x<=0 for x in row))for row in coefficients) +signed={tuple(s*x for x in r)for r in R for s in(-1,1)} +assert len(signed)==240 and len(basis(P[8:]))==9 +assert all(tuple(a)in signed and dot(a,a)==4 for a in simple) +assert all(sum(r[i]*r[j]for r in R[8:])==56*int(i==j)for i in range(8)for j in range(8)) +attaining=[len(basis([p for p,r in zip(P[8:],R[8:])if r[j]]))for j in range(8)] +assert attaining==[8]*8 +for a in simple: + for r in signed: + g=dot(a,r);assert g%2==0 and tuple(x-g//2*y for x,y in zip(r,a))in signed +weights=[[inv[i][j]for i in range(8)]for j in range(8)] +counts=[sum(dot(r,w)!=0 for r in R)for w in weights] +assert sorted(counts)[0]==57 and sorted(counts)[1]>=78 +short=weights[counts.index(57)] +assert tuple(2*x for x in short)in signed +zeros=[0]*9 +for mask in range(256): + z=sum(all(not row[j]or mask>>j&1 for j in range(8))for row in coefficients) + zeros[mask.bit_count()]=max(zeros[mask.bit_count()],z) +assert zeros==[0,1,3,6,12,20,36,63,120] +generalized=[53]+[112-zeros[8-d]for d in range(2,9)] +assert generalized==[53,76,92,100,106,109,111,112] +root_supports=[sum(1<>bit&1:anf[x]^=anf[x^(1<>(2*j))&1,(mask>>(2*j+1))&1 + if u:x^=a + if v:x^=b + value^=u*v^u*q(a)^v*q(b) + assert q(x)==value +# The sign hypothesis is needed. Its opposite permits a constant-one +# affine four-space and cannot support the rank-five capacity of twelve. +origin=0 +for a,b in pairs: + if q(a):origin^=b +constant_coset=[] +for mask in range(16): + x=origin + for j,(a,b)in enumerate(pairs): + if mask>>j&1:x^=a + constant_coset.append(x) +assert len(set(constant_coset))==16 and all(q(x)==0 for x in constant_coset) +assert sum(q(x)^1 for x in constant_coset)==16>12 +root_hyperplane_checks=[] +for p in P: + H=[x for x in range(256)if not(p&label(x)).bit_count()%2];a=H[0] + directions=basis([x^a for x in H]);assert len(H)==128 and len(directions)==7 + polar_rows=[sum(polar(u,v)<>(j-8)&1) +assert self_max<=21 +largest=[x for x in frames if x.bit_count()==36];large=[x for x in frames if x.bit_count()>=34] +assert len(largest)==448 and len(large)==4032 +large_union=max((s|t).bit_count()for s in largest for t in large) +assert large_union==66 +assert max(large_union,34+34,36+32)==68 +assert max(z.bit_count()for z in zero[1:])==64 + +# Check all full-root planes and the binary regular-simplex label model. +nonorthogonal=orthogonal=0 +for a,b in combinations(R,2): + g=dot(a,b);assert g in(-2,0,2) + solutions=[(A,B)for A,B in product((-2,0,2),repeat=2)if 4*(A*A+B*B)-2*g*A*B==4*(16-g*g)] + if not g:assert not solutions;orthogonal+=1 + else: + assert len(solutions)==2 + assert tuple(x-g//2*y for x,y in zip(a,b))in signed;nonorthogonal+=1 +edges=list(combinations(range(9),2));edge_labels={e:511^(1<>j&1 for p in star) + assert all(p>>j&1 for e,p in edge_labels.items()if j not in e) + for a,b in edges: + values=[2*int(i==a)-2*int(i==b)for i in range(9)] + for endpoint in(a,b): + shifted=[v-values[endpoint]for v in values] + assert shifted[endpoint]==0 and all(v!=0 for i,v in enumerate(shifted)if i!=endpoint) +report=dict(status='PASS_INDEPENDENT_PRIVATE64_GEOMETRIC_INPUTS',generalized_support_bounds=generalized, + zero_root_maxima=zeros,fundamental_support_counts=counts,quadratic_ones=sum(truth),quadratic_gauss_sum=16, + symplectic_pairs=pairs,arf_invariant=0,analytic_source_capacities=[0,1,2,4,8,12,20,36,64,112], + attaining_private_coordinate_frame_ranks=attaining, + negative_control='Complementing the quadratic sign produces an affine four-space with sixteen ones; the positive-Gauss hypothesis is necessary.', + root_nonself_hyperplanes_checked=len(root_hyperplane_checks),rank7_planes=len(planes),rank7_histogram=dict(hist), + maximum_root_intersection_rank7=maximum_root_intersection,maximum_rank7_intersection_when_self_port_present=self_max,maximum_rank7_pair_union=68, + large_pair_checks=len(largest)*len(large),nonorthogonal_root_planes=nonorthogonal,orthogonal_root_planes=orthogonal, + analytic_rank5_rank6_bounds_require_written_coisotropic_argument=True, + source_sha256={str(p):sha256(p.read_bytes()).hexdigest()for p in(source,chamber_path)},seconds=time.monotonic()-started, + scope='Exact chamber, quadratic, complete rank7 and simplex-model prerequisites. Uniform affine rank5/rank6 capacities and both algebraic query closures are supplied by the independent written audit. No scalar-private theorem is inferred solely from this finite receipt.') +out.write_text(json.dumps(report,indent=2)+'\n');print(report['status'],report['seconds']) diff --git a/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_profiles.py b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_profiles.py new file mode 100644 index 0000000000..eb90a9d109 --- /dev/null +++ b/research/private-query-concave-range/historical/work/autonomous-kappa-run/framework/private64_profiles.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +"""Enumerate scalar-query rank multiplicities with a separate recursion.""" + +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from math import comb +import json +from pathlib import Path +import sys +import time + +if not __debug__: + raise SystemExit('Run with assertions enabled.') +root,out=map(lambda s:Path(s).resolve(),sys.argv[1:3]);started=time.monotonic() +geometry_path=root/'framework/PRIVATE64-GEOMETRY.json';geometry=json.loads(geometry_path.read_text()) +capacity=geometry['analytic_source_capacities'];weights=[0]+geometry['generalized_support_bounds'] +counts=Counter();survivors=[];multiplicity=[0]*10 +def choose(n,k):return comb(n,k)if n>=k>=0 else 0 +concavity_checks=0 +for m in range(1,64): + for k in range(1,m+1): + coverage=[choose(m,k)-choose(m-x,k)for x in range(m+1)] + increments=[b-a for a,b in zip(coverage,coverage[1:])] + assert all(x>=y>=0 for x,y in zip(increments,increments[1:]));concavity_checks+=1 +assert Q(2)*(1-Q(comb(2,2),comb(4,2)))>1 +def screen(): + counts['all']+=1;n=sum(multiplicity) + if n<8:counts['row_rank']+=1;return + incidence=sum(capacity[r]*multiplicity[r]for r in range(1,10)) + if incidence<224-n:counts['column_incidence']+=1;return + parts=tuple(r for r in range(1,10)for _ in range(multiplicity[r])) + prefix=[0] + for r in parts:prefix.append(prefix[-1]+capacity[r]) + for d in range(1,9): + k=n-8+d + if prefix[k]17/18`, so the coefficient in the critical-point +formula is less than `4/9`. The fifth comparison bounds `8^a0` by +`13/3`. All inequalities are strict and all factors are positive. +Thus `F(a0)>2/27`. The derivative sign proves that this is a bound for +every `0<=a<=1`. + +An independent integer and Fraction calculation checked all five +comparisons, the two logarithmic coefficient reductions, the rational +margin, the chord coefficients, and both endpoints. The submitted +verifier was not imported. Decimal calculations were diagnostics only. +They give `a0` about `0.6659342077` and `F(a0)` about `0.2872388751`. +The exact proof uses the weaker bound `2/27`. + +The retained calculation is `independent_calculation.py`. It records all +five integer comparisons in `independent-calculation.json`. From the +repository root, run: + +```text +python3 work/fresh-research-20261012/private-bound/independent-review/independent_calculation.py +``` + +## Weighted extension + +The dependent-row step is valid for the stated factorization. Select a +basis from the query rows. Express each removed row in this basis and +add its decoder contribution to the retained decoder columns. Keep +the retained source frames. This preserves `G`. Every removed row has +a positive charge, including at both endpoints. + +If there are eight retained rows, their span equals the row space of +`G`. The support and capacity premises force every frame rank to be at +least eight. If total rank is 64, the maximum-rank premise gives the +weighted bound. In the remaining case, integer ranks give total rank +at least 65 and the row count is at least nine. These cases cover all +retained profiles. + +For `0<=a<=1`, the power function is concave. Its rank-one to rank-nine +chord has slope `(9^a-1)/8` and intercept `(9-9^a)/8`. Both are +nonnegative. Thus separate lower bounds on total rank and row count +can be used, including at `a=0` and `a=1`. The resulting expression +is exactly `7*9^a+2`. + +For `01`, the sharpness statement is valid if the stated model permits +an enlarged source frame. A rank-nine frame contains the rank-eight +frame. The cost decreases because `1-b<0`. This gives a cost-law +example only. It gives no physical circuit or recurrence claim. + +## Verification limit + +This review certifies the new scalar argument and its conditional +weighted consequence. It does not certify the fixed Gram code, +capacity bound, total-rank bound, profile classification, coordinate +gathers, or source-label invariance. No integer kappa improvement +follows from this lemma alone. The proof states this limit. + +No changes are required for the new argument. A submission must include +or cite reproducible evidence for all six premises. + +Prepared with OpenAI Codex assistance. New work is under Apache-2.0. diff --git a/research/private-query-concave-range/independent-review/independent-calculation.json b/research/private-query-concave-range/independent-review/independent-calculation.json new file mode 100644 index 0000000000..c9bb9a941b --- /dev/null +++ b/research/private-query-concave-range/independent-review/independent-calculation.json @@ -0,0 +1,44 @@ +{ + "status": "PASS", + "proof_inputs": "Independent integer and Fraction derivations; no historical replay and no import of the proposed verifier.", + "relations": [ + { + "lhs": "9^7", + "rhs": "8^8", + "gap": "11994247" + }, + { + "lhs": "8^96", + "rhs": "9^91", + "gap": "188272896003010888898225301338719215653367061824209053075550114811454739074763966643353" + }, + { + "lhs": "13^10 * 8^7", + "rhs": "12^10 * 9^7", + "gap": "7038621746987008" + }, + { + "lhs": "9^17", + "rhs": "8^18", + "gap": "1337216809815415" + }, + { + "lhs": "8^7 * 3^10", + "rhs": "13^10", + "gap": "14023763401" + } + ], + "numerical_diagnostics_only": { + "a0": "0.665934207733868176937976771420233818241345433627229324937208713105720154871515256933841352", + "F_a0": "0.2872388750589623595006315778936509155135740930693611221710635622871852344625221794041072", + "proof_gap": "0.0740740740740740740740740740740740740740740740740740740740740740740740740740740740740740741" + }, + "premises_not_verified": [ + "Fixed Gram code rank eight and support at least 53.", + "Frame rank from one to nine.", + "Rank at most seven has capacity at most 36.", + "Total rank at least 64.", + "Total-64 necessary profiles have maximum rank at most eight.", + "Eight rank-eight coordinate gathers factor the Gram code." + ] +} diff --git a/research/private-query-concave-range/independent-review/independent_calculation.py b/research/private-query-concave-range/independent-review/independent_calculation.py new file mode 100644 index 0000000000..08a63ee5ad --- /dev/null +++ b/research/private-query-concave-range/independent-review/independent_calculation.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python3 +"""Check the new scalar inputs without the submitted verifier. + +Use the six historical facts as premises. Decimal values are diagnostics +only. Prepared with OpenAI Codex assistance; Apache-2.0. +""" +from decimal import Decimal, localcontext +from fractions import Fraction +from pathlib import Path +import json + + +root = Path(__file__).resolve().parent +relations = [(7, 9, 8, 8), (96, 8, 91, 9), (17, 9, 18, 8)] +results = [] +for exponent_l, base_l, exponent_r, base_r in relations: + lhs = pow(base_l, exponent_l) + rhs = pow(base_r, exponent_r) + assert lhs < rhs + results.append({"lhs": f"{base_l}^{exponent_l}", + "rhs": f"{base_r}^{exponent_r}", + "gap": str(rhs - lhs)}) +assert pow(13, 10) * pow(8, 7) < pow(12, 10) * pow(9, 7) +assert pow(8, 7) * pow(3, 10) < pow(13, 10) +results.insert(2, {"lhs": "13^10 * 8^7", "rhs": "12^10 * 9^7", + "gap": str(pow(12, 10) * pow(9, 7) + - pow(13, 10) * pow(8, 7))}) +results.append({"lhs": "8^7 * 3^10", "rhs": "13^10", + "gap": str(pow(13, 10) - pow(8, 7) * pow(3, 10))}) +assert Fraction(8, 7) * Fraction(91, 96) == Fraction(13, 12) +assert 8 * (1 - Fraction(17, 18)) == Fraction(4, 9) +assert 2 - Fraction(4, 9) * Fraction(13, 3) == Fraction(2, 27) +# Derive the affine charge in x=9^a without the submitted script. +assert Fraction(65, 8) - Fraction(9, 8) == 7 +assert -Fraction(65, 8) + Fraction(81, 8) == 2 +# Check endpoint values and chord signs at exact sample values. +for x in [Fraction(1), Fraction(2), Fraction(5), Fraction(9)]: + slope = (x - 1) / 8 + intercept = (9 - x) / 8 + assert slope >= 0 and intercept >= 0 + assert 65 * slope + 9 * intercept == 7 * x + 2 +assert (7 + 2 - 8, 7 * 9 + 2 - 8 * 8) == (1, 1) +# Numerical diagnostics do not prove the inequality. +with localcontext() as ctx: + ctx.prec = 90 + l8 = Decimal(8).ln() + l9 = Decimal(9).ln() + a0 = (8 * l8 / (7 * l9)).ln() / (l9 - l8) + f0 = 7 * (a0 * l9).exp() + 2 - 8 * (a0 * l8).exp() + assert 0 < a0 < Decimal(7) / 10 + assert f0 > Decimal(2) / 27 + numerical = {"a0": str(a0), "F_a0": str(f0), + "proof_gap": str(Decimal(2) / 27)} +report = { + "status": "PASS", + "proof_inputs": "Independent integer and Fraction derivations; " + "no historical replay and no import of the proposed verifier.", + "relations": results, + "numerical_diagnostics_only": numerical, + "premises_not_verified": [ + "Fixed Gram code rank eight and support at least 53.", + "Frame rank from one to nine.", + "Rank at most seven has capacity at most 36.", + "Total rank at least 64.", + "Total-64 necessary profiles have maximum rank at most eight.", + "Eight rank-eight coordinate gathers factor the Gram code.", + ], +} +(root / "independent-calculation.json").write_text( + json.dumps(report, indent=2) + "\n") +print(json.dumps(numerical, indent=2)) diff --git a/research/private-query-concave-range/replay.log b/research/private-query-concave-range/replay.log new file mode 100644 index 0000000000..4965835d33 --- /dev/null +++ b/research/private-query-concave-range/replay.log @@ -0,0 +1,7 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -O -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar-optimized.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/independent-review/independent_calculation.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_geometry.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_profiles.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/rank-nine.json +PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS 2/27 1735600 diff --git a/research/private-query-concave-range/replayed-receipt.json b/research/private-query-concave-range/replayed-receipt.json new file mode 100644 index 0000000000..ab1ad09295 --- /dev/null +++ b/research/private-query-concave-range/replayed-receipt.json @@ -0,0 +1,80 @@ +{ + "status": "PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS", + "stages": [ + { + "name": "scalar", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar.json" + ], + "exit_code": 0 + }, + { + "name": "scalar-optimized", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar-optimized.json" + ], + "exit_code": 0 + }, + { + "name": "scalar-independent", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/independent-review/independent_calculation.py" + ], + "exit_code": 0 + }, + { + "name": "geometry", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json" + ], + "exit_code": 0 + }, + { + "name": "profiles", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_profiles.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json" + ], + "exit_code": 0 + }, + { + "name": "rank-nine", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/rank-nine.json" + ], + "exit_code": 0 + } + ], + "scalar_margin": "2/27", + "rank7_frames": 43435, + "profiles_through_63": 1735600, + "total64_partitions": 195666, + "rank9_partitions": 79403, + "scope": "Finite proof inputs only. The written real-variable argument, capacity bounds and two query-profile closures are required. No fitting-rigidity or physical supplier replay.", + "source_manifest_sha256": "18f71bd02658f094df21510fa45a9de39985abf8233052df45fb7ed8bf5d8dc5" +} diff --git a/research/private-query-concave-range/review/FINAL-HASHES.json b/research/private-query-concave-range/review/FINAL-HASHES.json new file mode 100644 index 0000000000..c1ba72285b --- /dev/null +++ b/research/private-query-concave-range/review/FINAL-HASHES.json @@ -0,0 +1,224 @@ +{ + "status": "PASS_FINAL_FILE_BINDING", + "package": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range", + "files": [ + { + "path": "HANDOFF.md", + "bytes": 2631, + "sha256": "b433ccd5a62c5b0721268e9a2c2c682ecef54a5bb7c687a3f6c731defad8752e" + }, + { + "path": "LOG.json", + "bytes": 3747, + "sha256": "c133420d523e3d884cbd0e254595a17d90c9a780844790be261b485b775a9704" + }, + { + "path": "OPTIMIZED-RESULT.json", + "bytes": 1784, + "sha256": "248de8384c88cc3ed07fcd1322ee2fa046b779df5c8881bf841f1fb366d7feb7" + }, + { + "path": "PROOF.md", + "bytes": 5001, + "sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994" + }, + { + "path": "README.md", + "bytes": 5822, + "sha256": "c82904c929ab37c3866bb7a1adc238364fa633df02baefbeab3aa85d40fd1607" + }, + { + "path": "RESULT.json", + "bytes": 1784, + "sha256": "827f0eb647b2cf132319e52e8bce1b76e830afc8f753feb6becdb299e5ae08d5" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 9715, + "sha256": "18f71bd02658f094df21510fa45a9de39985abf8233052df45fb7ed8bf5d8dc5" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md", + "bytes": 1451, + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json", + "bytes": 2592, + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "bytes": 358962, + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json", + "bytes": 1612, + "sha256": "bae45fa968c52e08bda082c82b1fde49aaefeaeec3c201fc56a937da58d75954" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json", + "bytes": 1980, + "sha256": "1c242fd2b12a05f6b1471251f9ef5a2f2335a2230f8524d96ddf9374d51bd0c5" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json", + "bytes": 2351, + "sha256": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md", + "bytes": 12638, + "sha256": "da037411ecc48265f2a9208ee6deb4e676048662276c783e66e7ec12299cd9ad" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json", + "bytes": 1246, + "sha256": "12c977b9f2891a8d664cb8e484afd88e591df8cf688333695dfd715b949cea75" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md", + "bytes": 5562, + "sha256": "54dae3bf87952431c833fd11f727cd39373ca32bbe9a6c08b2166c79259e53ca" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json", + "bytes": 1672, + "sha256": "044d97c688a3586bda135683b19d1c14ece8ed459ea252934c7c633aa9ac684b" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "bytes": 5025, + "sha256": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "bytes": 8942, + "sha256": "dbcfe11a877de04ed64a95f77e0c3ffdaa44d90f34e26d6fdf370e2402c13497" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64_profiles.py", + "bytes": 3196, + "sha256": "1e63e4b25d7690a008149489b9c945d129f5465b8d187026f4dc28eef9c1ef88" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ALL-GATHER.json", + "bytes": 59913, + "sha256": "75b539dadeebddf39a9c4e67d4d8900d1a1105760e546b05bfc056ae8353a209" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.json", + "bytes": 17919, + "sha256": "a99d7497710565dbfd598b1dd16ea4679b45db9d36761e2fb2f4c3a57429b21e" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.md", + "bytes": 4029, + "sha256": "5bb5ddb57e750abeca45dbdd2c72cb5b4284ba77b84689cddd5ada4930a9024f" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT-PROOF.md", + "bytes": 3464, + "sha256": "127899c6f3ce10cada05afa832a96852a6d3bf7d102a0a80016f981ac7601230" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT.json", + "bytes": 24711, + "sha256": "9792c58c3b0d3a074d82d2f66ce6dbb88669a3d4a07ec616dd94c26076593ae7" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT-PROOF.md", + "bytes": 1254, + "sha256": "c869ee34a13ff97122aaaddd5a37a5cbc00987b6d40e20387a4ee5b7fa872c76" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT.json", + "bytes": 1130, + "sha256": "9faf48161b26835aa41b40789087b596a748b4aa18c261f536600c11f473ec87" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-NINE-RANK7-QUERY-OBSTRUCTION.md", + "bytes": 5555, + "sha256": "a375ac919af87a27faaeeebfdf9d63495325681d22262f7846578baa19f5392d" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.json", + "bytes": 6521, + "sha256": "bf29e7f42d440b04cbd5af622cdf4bcaa116c64c936c75855229ff4b2507652b" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md", + "bytes": 4209, + "sha256": "3abbe847857f0afcfa8c9b8f0603d48eefea50c6e176e825e0a3de120ff81565" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-TEN-QUERY-PROFILE-OBSTRUCTION.md", + "bytes": 3541, + "sha256": "7e6d686a8d3d9514ab660457f4f8f1c8a5662788a9b643b28def3e6dbb561f90" + }, + { + "path": "independent-review/REVIEW.md", + "bytes": 3633, + "sha256": "be69181f904d4db711081b67eebcc8e3b844ee72ca76aaf463e1c87d769794cc" + }, + { + "path": "independent-review/independent-calculation.json", + "bytes": 1391, + "sha256": "92165f890ed1b22fe3d91e11841b00a8e95b366e60244008142e23db91f9f797" + }, + { + "path": "independent-review/independent_calculation.py", + "bytes": 2972, + "sha256": "249078959b50932308140a24cce96f557b5f5a164f6e4664694797a9e1ac0b25" + }, + { + "path": "replay.log", + "bytes": 2637, + "sha256": "4c68af8d53831bcfad13a9487feefd86fa764779d8da244408c9d685e2b43a10" + }, + { + "path": "replayed-receipt.json", + "bytes": 3950, + "sha256": "bf790fab8dba5fff0134e762784d63852962994f4d232fae06b9832929a3a1fa" + }, + { + "path": "verify.py", + "bytes": 4507, + "sha256": "0c0eaa9f04fbe5e525a0434cab38bb7bd2172e840098c96a11beae355fd8329c" + }, + { + "path": "verify_scalar_lemma.py", + "bytes": 2739, + "sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b" + } + ], + "review_changes": [ + "README.md", + "replay.log", + "replayed-receipt.json", + "verify.py" + ], + "review_files": [ + { + "path": "REVIEW.md", + "sha256": "95cf6796375d5966fa7fc30d873a578dc8770a8b5fde5b7bbbb1e165bb1e6551" + }, + { + "path": "review_checks.py", + "sha256": "c5e8461ec701d042a51bbd4c023025f87494c9557b44b24b8c4919590ac3d192" + }, + { + "path": "REPLAY-COMMAND.json", + "sha256": "0e14c9133f9aa8c84eaedb638f57ff1978c9b91bd4b02fdc66a8f5d442793abc" + }, + { + "path": "FINAL-REPLAY-COMMAND.json", + "sha256": "3285e7c78c8f8d679b440826b2378d75edc4899240a0555e538af98c74f58a04" + }, + { + "path": "controls-final/RESULT.json", + "sha256": "18d7371f4cad8e0e21ab744ceb698a05757595181a4bb10f9d74866e982bd8a2" + } + ] +} diff --git a/research/private-query-concave-range/review/FINAL-REPLAY-COMMAND.json b/research/private-query-concave-range/review/FINAL-REPLAY-COMMAND.json new file mode 100644 index 0000000000..0f7bcefa53 --- /dev/null +++ b/research/private-query-concave-range/review/FINAL-REPLAY-COMMAND.json @@ -0,0 +1,21 @@ +{ + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-I", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final" + ], + "exit_code": 0, + "seconds": 7.952172541001346, + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "environment": { + "PYTHONOPTIMIZE": "1", + "OMP_NUM_THREADS": "1", + "OPENBLAS_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "VECLIB_MAXIMUM_THREADS": "1" + }, + "verify_sha256": "0c0eaa9f04fbe5e525a0434cab38bb7bd2172e840098c96a11beae355fd8329c" +} diff --git a/research/private-query-concave-range/review/INPUT-HASHES.json b/research/private-query-concave-range/review/INPUT-HASHES.json new file mode 100644 index 0000000000..eafa55f194 --- /dev/null +++ b/research/private-query-concave-range/review/INPUT-HASHES.json @@ -0,0 +1,195 @@ +{ + "package": "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range", + "files": [ + { + "path": "HANDOFF.md", + "bytes": 2631, + "sha256": "b433ccd5a62c5b0721268e9a2c2c682ecef54a5bb7c687a3f6c731defad8752e" + }, + { + "path": "LOG.json", + "bytes": 3747, + "sha256": "c133420d523e3d884cbd0e254595a17d90c9a780844790be261b485b775a9704" + }, + { + "path": "OPTIMIZED-RESULT.json", + "bytes": 1784, + "sha256": "248de8384c88cc3ed07fcd1322ee2fa046b779df5c8881bf841f1fb366d7feb7" + }, + { + "path": "PROOF.md", + "bytes": 5001, + "sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994" + }, + { + "path": "README.md", + "bytes": 5558, + "sha256": "c978f17c498304928fdbddfd55a9aef9dfa9bcd6c2df59fd05e187c65dd9d556" + }, + { + "path": "RESULT.json", + "bytes": 1784, + "sha256": "827f0eb647b2cf132319e52e8bce1b76e830afc8f753feb6becdb299e5ae08d5" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 9715, + "sha256": "18f71bd02658f094df21510fa45a9de39985abf8233052df45fb7ed8bf5d8dc5" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/NOTICE.md", + "bytes": 1451, + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/SOURCES.json", + "bytes": 2592, + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "path": "historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "bytes": 358962, + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/GENERALIZED-QUERY-PROFILES.json", + "bytes": 1612, + "sha256": "bae45fa968c52e08bda082c82b1fde49aaefeaeec3c201fc56a937da58d75954" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-FINAL-BINDING.json", + "bytes": 1980, + "sha256": "1c242fd2b12a05f6b1471251f9ef5a2f2335a2230f8524d96ddf9374d51bd0c5" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json", + "bytes": 2351, + "sha256": "ad4aa4dab3cd4381dd5edd86845dac4a4693cfd16d746f9f1141515a05db7ac5" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-INDEPENDENT-REVIEW.md", + "bytes": 12638, + "sha256": "da037411ecc48265f2a9208ee6deb4e676048662276c783e66e7ec12299cd9ad" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json", + "bytes": 1246, + "sha256": "12c977b9f2891a8d664cb8e484afd88e591df8cf688333695dfd715b949cea75" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/PROOF.md", + "bytes": 5562, + "sha256": "54dae3bf87952431c833fd11f727cd39373ca32bbe9a6c08b2166c79259e53ca" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/ROOT-INDEPENDENT.json", + "bytes": 1672, + "sha256": "044d97c688a3586bda135683b19d1c14ece8ed459ea252934c7c633aa9ac684b" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "bytes": 5025, + "sha256": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "bytes": 8942, + "sha256": "dbcfe11a877de04ed64a95f77e0c3ffdaa44d90f34e26d6fdf370e2402c13497" + }, + { + "path": "historical/work/autonomous-kappa-run/framework/private64_profiles.py", + "bytes": 3196, + "sha256": "1e63e4b25d7690a008149489b9c945d129f5465b8d187026f4dc28eef9c1ef88" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ALL-GATHER.json", + "bytes": 59913, + "sha256": "75b539dadeebddf39a9c4e67d4d8900d1a1105760e546b05bfc056ae8353a209" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.json", + "bytes": 17919, + "sha256": "a99d7497710565dbfd598b1dd16ea4679b45db9d36761e2fb2f4c3a57429b21e" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-ANALYTIC-FRAME-CAPACITIES.md", + "bytes": 4029, + "sha256": "5bb5ddb57e750abeca45dbdd2c72cb5b4284ba77b84689cddd5ada4930a9024f" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT-PROOF.md", + "bytes": 3464, + "sha256": "127899c6f3ce10cada05afa832a96852a6d3bf7d102a0a80016f981ac7601230" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-GENERALIZED-SUPPORT.json", + "bytes": 24711, + "sha256": "9792c58c3b0d3a074d82d2f66ce6dbb88669a3d4a07ec616dd94c26076593ae7" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT-PROOF.md", + "bytes": 1254, + "sha256": "c869ee34a13ff97122aaaddd5a37a5cbc00987b6d40e20387a4ee5b7fa872c76" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-MINIMUM-SUPPORT.json", + "bytes": 1130, + "sha256": "9faf48161b26835aa41b40789087b596a748b4aa18c261f536600c11f473ec87" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-NINE-RANK7-QUERY-OBSTRUCTION.md", + "bytes": 5555, + "sha256": "a375ac919af87a27faaeeebfdf9d63495325681d22262f7846578baa19f5392d" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.json", + "bytes": 6521, + "sha256": "bf29e7f42d440b04cbd5af622cdf4bcaa116c64c936c75855229ff4b2507652b" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-PRIVATE-QUERY-OPTIMUM64.md", + "bytes": 4209, + "sha256": "3abbe847857f0afcfa8c9b8f0603d48eefea50c6e176e825e0a3de120ff81565" + }, + { + "path": "historical/work/p518-next/complex/paired-five/E8-TEN-QUERY-PROFILE-OBSTRUCTION.md", + "bytes": 3541, + "sha256": "7e6d686a8d3d9514ab660457f4f8f1c8a5662788a9b643b28def3e6dbb561f90" + }, + { + "path": "independent-review/REVIEW.md", + "bytes": 3633, + "sha256": "be69181f904d4db711081b67eebcc8e3b844ee72ca76aaf463e1c87d769794cc" + }, + { + "path": "independent-review/independent-calculation.json", + "bytes": 1391, + "sha256": "92165f890ed1b22fe3d91e11841b00a8e95b366e60244008142e23db91f9f797" + }, + { + "path": "independent-review/independent_calculation.py", + "bytes": 2972, + "sha256": "249078959b50932308140a24cce96f557b5f5a164f6e4664694797a9e1ac0b25" + }, + { + "path": "replay.log", + "bytes": 2696, + "sha256": "612a564ab11bc086582a83297c57dff34add2e544dff1fb5e4ecab9d957b727c" + }, + { + "path": "replayed-receipt.json", + "bytes": 3943, + "sha256": "9e4b5b1d66cf08a93b11165a604effdf41854950bdbb870c1760513743ce53b9" + }, + { + "path": "verify.py", + "bytes": 4477, + "sha256": "676ac1a793879cd59594d47077a9346106f08d48340122cc00a4fd98e8830b61" + }, + { + "path": "verify_scalar_lemma.py", + "bytes": 2739, + "sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b" + } + ] +} diff --git a/research/private-query-concave-range/review/RELATED-WORK.json b/research/private-query-concave-range/review/RELATED-WORK.json new file mode 100644 index 0000000000..a8bb7f94ee --- /dev/null +++ b/research/private-query-concave-range/review/RELATED-WORK.json @@ -0,0 +1,31 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "open_pr_records": [ + { + "number": 3074, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3074", + "title": "One-sided padding lemma: P112 to P120 at cost exactly +8 (L120 suffices for Delta >= n_nf)", + "headRefOid": "3cc41f260c31052c933d0e75ea02f2b7677e780c", + "body_sha256": "8beb1a686722bb2483562c8e3a06bca0ef28aafbbc11c52773737bf0f367a875" + }, + { + "number": 2985, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2985", + "title": "Research: one-sided residue closures \u2014 Circuit Lemma, relative root counting and plane lemma close 480 of the 603 d>=4 residues (116 open; no kappa claim)", + "headRefOid": "b07b0e3226bcbe32a90c1b43ab225c339086f7b5", + "body_sha256": "ba774aae80f15fc13f74dced734656ea775555bf51bf7a08703e8337484d9bf2" + } + ], + "read_pinned_files": [ + { + "commit": "4c32ac3b88d63ad06d2b30e526aa07a12929db36", + "path": "research/one-sided-decoders-all-m/README.md", + "sha256": "7c22a8d73d8e2cf1ec9ce259035fe97be7261b0f71d5555ee50fc4b821872bf8" + }, + { + "commit": "4c32ac3b88d63ad06d2b30e526aa07a12929db36", + "path": "research/one-sided-decoders-all-m/NOTICE.md", + "sha256": "ada70c49b9c92012927b5fd83f147eaba9f7844f03c4326527454030531f632f" + } + ] +} diff --git a/research/private-query-concave-range/review/REPLAY-COMMAND.json b/research/private-query-concave-range/review/REPLAY-COMMAND.json new file mode 100644 index 0000000000..723f59ed95 --- /dev/null +++ b/research/private-query-concave-range/review/REPLAY-COMMAND.json @@ -0,0 +1,18 @@ +{ + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay" + ], + "exit_code": 0, + "seconds": 14.974779250042047, + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "thread_environment": { + "OMP_NUM_THREADS": "1", + "OPENBLAS_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "VECLIB_MAXIMUM_THREADS": "1" + } +} diff --git a/research/private-query-concave-range/review/REVIEW.md b/research/private-query-concave-range/review/REVIEW.md new file mode 100644 index 0000000000..c7eed913dc --- /dev/null +++ b/research/private-query-concave-range/review/REVIEW.md @@ -0,0 +1,172 @@ +# Independent review of the private-query concave cost bound + +Result: PASS for the fixed source-frame model. The submitted proof gives +the exact minimum `8*8^(1-b)` for every real `0 <= b <= 1`. It applies +to every finite scalar factorization over Q, R or C. It does not give +a circuit, a physical copy-cost theorem, or a complete kappa improvement. + +This is an independent OpenAI Codex agent review. It is not human review +or formal proof checking. The reviewer read the PR description standard +at `/Users/aliromman/Projects/IntegerMultiplicationBounds/PR-DESCRIPTION-STANDARD.md`. +No new research direction was used to complete this review. + +## Exact model + +The prototype has 120 root rows of length eight. The matrix `R` consists +of rows 8 through 119, so it has size 112 by 8. The correction +`G=R R^T/4` has size 112 by 112. The exact identity `R^T R=56 I_8` +proves that its rank is eight over each stated field. There is no +transpose conflict with other packages that store roots as columns. + +For each nonzero query row `f_j`, a private binary linear subspace +`F_j <= F_2^9` must contain all source labels in its support. The charge +uses `r_j=dim_F2(F_j)`, with `1 <= r_j <= 9`. A frame may contain more +vectors than the minimal support span. This permission is part of the +historical model and is now explicit in the package README. + +This rank is not the rank of a source-target pairing submatrix. +A pairing can have a nonzero kernel on the source span. The proof does +not subtract that kernel dimension. It also does not assign a shared +carrier's chronological cost to several queries. + +## The six premises + +All required finite inputs are in the package. The following written +arguments were checked, as well as their fresh exact computations. + +1. **Code rank and support.** The simple-root certificate checks every + signed-root reflection, every one-sign integral root expansion, and + all 256 simple subsets. The finite chamber argument is valid. It + gives the stated generalized support bounds. The unique short + fundamental ray is a root direction. Thus the retained minimum + support is 53; a non-root real direction has support at least 70. + Real and imaginary parts give the stated complex-field extension. +2. **Frame ranks.** Nonzero rows require a positive rank. All frames + lie in the fixed nine-dimensional binary source space. Enlarged + frames are permitted; minimal frames are not required. +3. **Source capacities.** The positive quadratic character sum is + checked from the literal labels. On a minimum-rank coisotropic + slice, exactly one coset has nonzero character sum. Its sum equals + the positive full sum. The remaining polar ranks give the bounds + 12, 20 and 36. This proves the low-rank capacities used by the + profile argument. All 43,435 rank-seven frames are also checked. +4. **Total rank at least 64.** Independent query reduction preserves + the correction and keeps the retained frames. The incidence bound + uses pairwise nonproportional correction columns. The balanced + incidence bound follows from decreasing discrete increments of + subset coverage; it does not assume disjoint supports. The fresh + enumeration covers all 1,735,600 profiles with total rank at most + 63 and leaves exactly the two profiles stated in the proof. + Both final closures are valid. Nine rank-seven rows force a root + simplex; its separating labels contradict the frame ranks. + The ten-query profile forces eight independent root directions to + have the same self port, which is impossible. +5. **No rank-nine frame at total 64.** The independent multiplicity + recursion covers all 195,666 partitions of 64. It rejects all + 79,403 partitions with a rank-nine part by valid necessary + conditions. The root-pair test is necessary and its omission + control produces the recorded survivor. This screen does not + assert that each remaining partition is realizable. +6. **Attainment.** The eight coordinate rows of `R^T`, with decoder + `R/4`, factor `G`. Each coordinate support has binary span rank + eight. A separate review calculation constructs those eight spans + and checks an explicit rank-nine enlargement of each one. + +The rank-five and rank-six capacity bounds use a written quadratic +argument. A second large census is not needed or claimed. The two +final query-profile contradictions are written proofs, not conclusions +of the profile enumeration alone. + +## The new scalar and weighted arguments + +For `F(a)=7*9^a+2-8*8^a`, the ratio of the two positive derivative +terms increases strictly. It crosses one at a unique critical point. +The five integer inequalities in the proof give `02-(4/9)*(13/3)=2/27`. This proves the strict inequality on +the whole real interval `[0,1]`. No numerical sample is a proof input. + +Deleting a dependent query removes a strictly positive charge, even +at the endpoints. Its decoder column can be absorbed into the retained +query columns. This reduction handles any finite number of terms. +For an independent query basis, exactly eight queries span the Gram +code and must each have frame rank at least eight. At total rank 64, +the no-rank-nine premise gives the weighted bound. All other cases +have at least nine queries and rank sum at least 65. The chord for +`r^a` on `[1,9]` has nonnegative slope and intercept for `0<=a<=1`. +The stated lower bounds on query count and rank sum can therefore +be used separately. They give `7*9^a+2`, strictly above the reference. + +For `01`, enlarging the eight coordinate +frames to rank nine is legal and gives a strictly smaller bill. +The separate exact check at `b=2` gives bills `1` and `8/9`. +No physical circuit claim follows from that cost-law example. + +## Current public context and credit + +The all-m decoder note was read at commit +`4c32ac3b88d63ad06d2b30e526aa07a12929db36`, including its source-rank +lift and the distinction between uncorrected and corrected pairing +cost. It already proves an unweighted floor and a unique cost-64 +decoder in its stated characteristic-zero model. The submitted note +does not claim that unweighted floor as new. It retains its own fixed +root and label dependency proof; no unproved identification of the +two coordinate systems is required. + +The current saved open-PR records for PR #3074 and PR #2985 concern +one-sided padding and corrected-decoder residue closures. Their stated +claims do not provide the present full concave weighted cost law. +A search of README and PROOF files at current main +`cef4b52f2a59009865bf8eabde1be3f159063703` found no copy of the new +scalar inequality or a claim of this full range. This is a targeted +overlap check, not a claim to have reviewed all public mathematics. + +The prototype, source notice and credit record are byte-identical to +their Git objects at `e07a8a3f9f79c22113398a0c5dbbc7601f489b3e`. +The notice verifies the credit to icekylinx. The README at commit +`9c94857bbaee886f8649edee0bc2d3c738f9555e` in the source project +identifies Jacob Sussman as its author and records its E8 construction. +The later decoder note's notice credits DreamingOfClouds and Claude +Opus 5.5. No file from that later proof is used as a computation input. +Live GitHub link and rendered-description checks remain the +coordinator's publication checks. + +## Runs, controls and final binding + +`REPLAY-COMMAND.json` records the first fresh six-stage replay. +`FINAL-REPLAY-COMMAND.json` records the final wrapper replay with +ambient `PYTHONOPTIMIZE=1` and an isolated parent interpreter. Each +child now uses `-E`; the explicit optimized scalar check still uses +`-O`. The final run passed in 7.952 seconds with one process at a time. +The time is a run record, not a performance claim. + +Both runs printed: + +```text +PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS 2/27 1735600 +``` + +`review_checks.py` imports no submitted checker. It checks the exact +source bindings, coordinate frame ranks and frame enlargements. +`controls-final/RESULT.json` records seven rejection controls: +optimized runner use, an existing output directory, a false scalar +comparison in normal and optimized Python, prototype manifest drift, +an altered root norm, and a duplicate binary source label. Every +control failed with the expected diagnostic. The historical replay +also passed its quadratic-sign and rank-nine premise-omission controls. + +The final README defines both the matrix orientation and permitted +frame enlargement. The saved package replay receipt and log now come +from the final run and bind the current source manifest. These changes +resolve the review's packaging findings. No material finding remains. +`FINAL-HASHES.json` records every final package file and the review +scripts. The original proof and historical sources were not changed. + +The optional fitting-rigidity extensions were not reverified and are +not part of the new claim. No physical supplier, phase, restoration, +hosting, recursive-cost or complete exponent check was run, because +the submitted result claims none of those operations or costs. diff --git a/research/private-query-concave-range/review/controls-final/RESULT.json b/research/private-query-concave-range/review/controls-final/RESULT.json new file mode 100644 index 0000000000..0df9e183b2 --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/RESULT.json @@ -0,0 +1,178 @@ +{ + "status": "PASS_INDEPENDENT_BINDINGS_AND_SEVEN_CONTROLS", + "retained_matrix_dimensions": [ + 112, + 8 + ], + "gram_dimensions": [ + 112, + 112 + ], + "gram_rank_certificate": "R^T R=56 I_8", + "coordinate_frames": [ + { + "coordinate": 0, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 13, + "enlarged_rank": 9 + }, + { + "coordinate": 1, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 2, + "enlarged_rank": 9 + }, + { + "coordinate": 2, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 400, + "enlarged_rank": 9 + }, + { + "coordinate": 3, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 13, + "enlarged_rank": 9 + }, + { + "coordinate": 4, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 400, + "enlarged_rank": 9 + }, + { + "coordinate": 5, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 13, + "enlarged_rank": 9 + }, + { + "coordinate": 6, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 13, + "enlarged_rank": 9 + }, + { + "coordinate": 7, + "support_size": 56, + "rank": 8, + "enlarging_source_label": 2, + "enlarged_rank": 9 + } + ], + "b_equal_2_costs": { + "rank8": "1", + "rank9": "8/9" + }, + "source_bindings": [ + { + "commit": "e07a8a3f9f79c22113398a0c5dbbc7601f489b3e", + "path": "research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "commit": "e07a8a3f9f79c22113398a0c5dbbc7601f489b3e", + "path": "research/direct-delivery504-global/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "commit": "e07a8a3f9f79c22113398a0c5dbbc7601f489b3e", + "path": "research/direct-delivery504-global/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + } + ], + "controls": [ + { + "name": "optimized-runner", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/must-not-create" + ], + "exit_code": 1, + "expected_text": "Run this verifier without -O" + }, + { + "name": "existing-build", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final" + ], + "exit_code": 1, + "expected_text": "The build directory exists." + }, + { + "name": "invalid-scalar-normal", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/normal.json" + ], + "exit_code": 1, + "expected_text": "positive_critical_point" + }, + { + "name": "invalid-scalar-optimized", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/optimized.json" + ], + "exit_code": 1, + "expected_text": "positive_critical_point" + }, + { + "name": "manifest-root-drift", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/verify.py", + "--build", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/must-not-create-drift" + ], + "exit_code": 1, + "expected_text": "Source hash:" + }, + { + "name": "geometric-root-drift", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/bad-root.json" + ], + "exit_code": 1, + "expected_text": "AssertionError" + }, + { + "name": "geometric-label-drift", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/bad-label.json" + ], + "exit_code": 1, + "expected_text": "AssertionError" + } + ], + "scope": "Exact fixed source, frame enlargement and rejection controls. The uniform real-variable theorem and the two final profile closures require written proof review." +} diff --git a/research/private-query-concave-range/review/controls-final/existing-build.stderr.log b/research/private-query-concave-range/review/controls-final/existing-build.stderr.log new file mode 100644 index 0000000000..e793525da9 --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/existing-build.stderr.log @@ -0,0 +1,10 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", line 88, in + main() + ~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", line 30, in main + require(not build.exists(), "The build directory exists.") + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify.py", line 18, in require + raise ValueError(message) +ValueError: The build directory exists. diff --git a/research/private-query-concave-range/review/controls-final/existing-build.stdout.log b/research/private-query-concave-range/review/controls-final/existing-build.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/geometric-label-drift.stderr.log b/research/private-query-concave-range/review/controls-final/geometric-label-drift.stderr.log new file mode 100644 index 0000000000..ab760527ae --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/geometric-label-drift.stderr.log @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run/framework/private64_geometry.py", line 39, in + assert len(set(P))==120 and all(p.bit_count()%2 for p in P) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/research/private-query-concave-range/review/controls-final/geometric-label-drift.stdout.log b/research/private-query-concave-range/review/controls-final/geometric-label-drift.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/geometric-root-drift.stderr.log b/research/private-query-concave-range/review/controls-final/geometric-root-drift.stderr.log new file mode 100644 index 0000000000..4d5b148719 --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/geometric-root-drift.stderr.log @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/historical/work/autonomous-kappa-run/framework/private64_geometry.py", line 40, in + assert all(dot(r,r)==4 for r in R) + ~~~^^^^^^^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/research/private-query-concave-range/review/controls-final/geometric-root-drift.stdout.log b/research/private-query-concave-range/review/controls-final/geometric-root-drift.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/invalid-scalar-normal.stderr.log b/research/private-query-concave-range/review/controls-final/invalid-scalar-normal.stderr.log new file mode 100644 index 0000000000..ed9d90a8fa --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/invalid-scalar-normal.stderr.log @@ -0,0 +1,10 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 75, in + main() + ~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 47, in main + pairs, margin = verify() + ~~~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 26, in verify + raise ValueError(name) +ValueError: positive_critical_point diff --git a/research/private-query-concave-range/review/controls-final/invalid-scalar-normal.stdout.log b/research/private-query-concave-range/review/controls-final/invalid-scalar-normal.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/invalid-scalar-optimized.stderr.log b/research/private-query-concave-range/review/controls-final/invalid-scalar-optimized.stderr.log new file mode 100644 index 0000000000..ed9d90a8fa --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/invalid-scalar-optimized.stderr.log @@ -0,0 +1,10 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 75, in + main() + ~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 47, in main + pairs, margin = verify() + ~~~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/invalid_scalar.py", line 26, in verify + raise ValueError(name) +ValueError: positive_critical_point diff --git a/research/private-query-concave-range/review/controls-final/invalid-scalar-optimized.stdout.log b/research/private-query-concave-range/review/controls-final/invalid-scalar-optimized.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/manifest-root-drift.stderr.log b/research/private-query-concave-range/review/controls-final/manifest-root-drift.stderr.log new file mode 100644 index 0000000000..d3d18a2f45 --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/manifest-root-drift.stderr.log @@ -0,0 +1,12 @@ +Traceback (most recent call last): + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/verify.py", line 88, in + main() + ~~~~^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/verify.py", line 33, in main + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + == item["sha256"], "Source hash: " + item["package"]) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/controls-final/tampered-package/verify.py", line 18, in require + raise ValueError(message) +ValueError: Source hash: historical/work/autonomous-kappa-run/baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json diff --git a/research/private-query-concave-range/review/controls-final/manifest-root-drift.stdout.log b/research/private-query-concave-range/review/controls-final/manifest-root-drift.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/controls-final/optimized-runner.stderr.log b/research/private-query-concave-range/review/controls-final/optimized-runner.stderr.log new file mode 100644 index 0000000000..b6bd64d074 --- /dev/null +++ b/research/private-query-concave-range/review/controls-final/optimized-runner.stderr.log @@ -0,0 +1 @@ +Run this verifier without -O. Historical sources use assert. diff --git a/research/private-query-concave-range/review/controls-final/optimized-runner.stdout.log b/research/private-query-concave-range/review/controls-final/optimized-runner.stdout.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/replay-final.stderr.log b/research/private-query-concave-range/review/replay-final.stderr.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/replay-final.stdout.log b/research/private-query-concave-range/review/replay-final.stdout.log new file mode 100644 index 0000000000..4965835d33 --- /dev/null +++ b/research/private-query-concave-range/review/replay-final.stdout.log @@ -0,0 +1,7 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -O -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar-optimized.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/independent-review/independent_calculation.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_geometry.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_profiles.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -E -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/rank-nine.json +PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS 2/27 1735600 diff --git a/research/private-query-concave-range/review/replay-final/rank-nine.json b/research/private-query-concave-range/review/replay-final/rank-nine.json new file mode 100644 index 0000000000..8ab9ec990c --- /dev/null +++ b/research/private-query-concave-range/review/replay-final/rank-nine.json @@ -0,0 +1,86 @@ +{ + "status": "PASS_INDEPENDENT_WEIGHTED_RANK_NINE_EXCLUSION", + "partitions": 195666, + "rank_nine_partitions": 79403, + "simple_survivors": [ + { + "profile": [ + 1, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9 + ], + "rejection": { + "reason": "average", + "dimension": 2, + "subset_size": 5, + "selected_rows": 9, + "upper_mean": "455/6", + "required": 76 + } + }, + { + "profile": [ + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 7, + 9 + ], + "rejection": { + "reason": "average", + "dimension": 2, + "subset_size": 4, + "selected_rows": 7, + "upper_mean": "72", + "required": 76 + } + }, + { + "profile": [ + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9 + ], + "rejection": { + "reason": "short_root_pair", + "upper_root_support": 52, + "required": 53 + } + } + ], + "root_pair_omission_survivors": 1, + "relaxed_support_control": [ + 1, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "larger_total_ratio_lower_at_b_1_over_32": "16575/16384", + "geometry_sha256": "2d20d5f50b68ab2cfaaca582dfb573d6e1dbe9d7369447c76e34b298b6806729", + "checker_sha256": "a162073fe121011ce3a0f902347455a2cd3b156b578bbe45b775706cda55c1a4", + "seconds": 0.6758636250160635, + "scope": "Independent necessary-condition audit for total64 profiles with a rank9 query. Prior sharp64 and geometry proofs remain premises. No new circuit or kappa gain." +} diff --git a/research/private-query-concave-range/review/replay-final/receipt.json b/research/private-query-concave-range/review/replay-final/receipt.json new file mode 100644 index 0000000000..ab1ad09295 --- /dev/null +++ b/research/private-query-concave-range/review/replay-final/receipt.json @@ -0,0 +1,80 @@ +{ + "status": "PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS", + "stages": [ + { + "name": "scalar", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar.json" + ], + "exit_code": 0 + }, + { + "name": "scalar-optimized", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-O", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/scalar-optimized.json" + ], + "exit_code": 0 + }, + { + "name": "scalar-independent", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/independent-review/independent_calculation.py" + ], + "exit_code": 0 + }, + { + "name": "geometry", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_geometry.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json" + ], + "exit_code": 0 + }, + { + "name": "profiles", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64_profiles.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json" + ], + "exit_code": 0 + }, + { + "name": "rank-nine", + "command": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-E", + "-B", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py", + "/Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay-final/rank-nine.json" + ], + "exit_code": 0 + } + ], + "scalar_margin": "2/27", + "rank7_frames": 43435, + "profiles_through_63": 1735600, + "total64_partitions": 195666, + "rank9_partitions": 79403, + "scope": "Finite proof inputs only. The written real-variable argument, capacity bounds and two query-profile closures are required. No fitting-rigidity or physical supplier replay.", + "source_manifest_sha256": "18f71bd02658f094df21510fa45a9de39985abf8233052df45fb7ed8bf5d8dc5" +} diff --git a/research/private-query-concave-range/review/replay-final/scalar-optimized.json b/research/private-query-concave-range/review/replay-final/scalar-optimized.json new file mode 100644 index 0000000000..f6926bd9c6 --- /dev/null +++ b/research/private-query-concave-range/review/replay-final/scalar-optimized.json @@ -0,0 +1,51 @@ +{ + "status": "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", + "strict_gap_lower": "2/27", + "integer_comparisons": [ + { + "name": "positive_critical_point", + "left": "4782969", + "right": "16777216", + "positive_gap": "11994247" + }, + { + "name": "critical_log_ratio", + "left": "497323236409786642155382248146820840100456150797347717440463976893159497012533375533056", + "right": "685596132412797531053607549485540055753823212621556770516014091704614236087297342176409", + "positive_gap": "188272896003010888898225301338719215653367061824209053075550114811454739074763966643353" + }, + { + "name": "critical_point_below_seven_tenths", + "left": "289110211898114048", + "right": "296148833645101056", + "positive_gap": "7038621746987008" + }, + { + "name": "minimum_coefficient_below_four_ninths", + "left": "16677181699666569", + "right": "18014398509481984", + "positive_gap": "1337216809815415" + }, + { + "name": "power_below_thirteen_thirds", + "left": "123834728448", + "right": "137858491849", + "positive_gap": "14023763401" + } + ], + "chord_at_rank_total_65_query_count_9": [ + 2, + 7 + ], + "assumptions_not_replayed": [ + "Fixed Gram code has rank eight and minimum support 53.", + "Source-frame ranks are one through nine.", + "Rank-seven source capacity is at most 36.", + "Total private frame rank is at least 64.", + "Total-64 feasible profiles have no rank-nine frame.", + "Eight rank-eight coordinate gathers factor the Gram code." + ], + "script_sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "proof_sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "seconds": 0.0005649169906973839 +} diff --git a/research/private-query-concave-range/review/replay-final/scalar.json b/research/private-query-concave-range/review/replay-final/scalar.json new file mode 100644 index 0000000000..3f3a36364c --- /dev/null +++ b/research/private-query-concave-range/review/replay-final/scalar.json @@ -0,0 +1,51 @@ +{ + "status": "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", + "strict_gap_lower": "2/27", + "integer_comparisons": [ + { + "name": "positive_critical_point", + "left": "4782969", + "right": "16777216", + "positive_gap": "11994247" + }, + { + "name": "critical_log_ratio", + "left": "497323236409786642155382248146820840100456150797347717440463976893159497012533375533056", + "right": "685596132412797531053607549485540055753823212621556770516014091704614236087297342176409", + "positive_gap": "188272896003010888898225301338719215653367061824209053075550114811454739074763966643353" + }, + { + "name": "critical_point_below_seven_tenths", + "left": "289110211898114048", + "right": "296148833645101056", + "positive_gap": "7038621746987008" + }, + { + "name": "minimum_coefficient_below_four_ninths", + "left": "16677181699666569", + "right": "18014398509481984", + "positive_gap": "1337216809815415" + }, + { + "name": "power_below_thirteen_thirds", + "left": "123834728448", + "right": "137858491849", + "positive_gap": "14023763401" + } + ], + "chord_at_rank_total_65_query_count_9": [ + 2, + 7 + ], + "assumptions_not_replayed": [ + "Fixed Gram code has rank eight and minimum support 53.", + "Source-frame ranks are one through nine.", + "Rank-seven source capacity is at most 36.", + "Total private frame rank is at least 64.", + "Total-64 feasible profiles have no rank-nine frame.", + "Eight rank-eight coordinate gathers factor the Gram code." + ], + "script_sha256": "817bd26766c3f3ba2274ca4b381cbdcc3cf763c9040e488bfb82808943fc128b", + "proof_sha256": "d9354408326a7b401b4003a1116d9e4c482b90f7b70e9d54fdf93704af995994", + "seconds": 0.0007051660213619471 +} diff --git a/research/private-query-concave-range/review/replay.stderr.log b/research/private-query-concave-range/review/replay.stderr.log new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/private-query-concave-range/review/replay.stdout.log b/research/private-query-concave-range/review/replay.stdout.log new file mode 100644 index 0000000000..f852f3ea84 --- /dev/null +++ b/research/private-query-concave-range/review/replay.stdout.log @@ -0,0 +1,7 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/scalar.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -O -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/packages/private-query-concave-range/verify_scalar_lemma.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/scalar-optimized.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/independent-review/independent_calculation.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run/framework/private64_geometry.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run/framework/private64_profiles.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/historical/work/autonomous-kappa-run/framework/private64-weighted/independent_max_rank.py /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/concave-cost/replay/rank-nine.json +PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS 2/27 1735600 diff --git a/research/private-query-concave-range/review/review_checks.py b/research/private-query-concave-range/review/review_checks.py new file mode 100644 index 0000000000..f526835e4c --- /dev/null +++ b/research/private-query-concave-range/review/review_checks.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""Run independent bindings and rejection controls for the cost proof. + +Use one process at a time. Use integer and rational arithmetic for every +claim. Prepared by an independent OpenAI Codex review agent. +""" +from fractions import Fraction +from hashlib import sha256 +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def span(rows): + values = {0} + for row in rows: + values |= {value ^ row for value in values} + return values + + +package = Path(sys.argv[1]).resolve() +out = Path(sys.argv[2]).resolve() +require(not out.exists(), "Output exists") +out.mkdir(parents=True) +historical = Path("historical/work/autonomous-kappa-run") +prototype = historical / "baseline535/source531/research/direct-delivery504-global/inputs/hamming/PROTOTYPE.json" +raw = (package / prototype).read_bytes() +data = json.loads(raw) +roots = data["root_lines"][8:] +labels = data["binary_ports"][8:] +require(len(roots) == len(labels) == 112, "Retained row count") +require(all(len(row) == 8 for row in roots), "Retained column count") +require(len(span(labels)) == 512, "Ambient label rank") +rt_r = [[sum(row[i] * row[j] for row in roots) for j in range(8)] + for i in range(8)] +require(rt_r == [[56 * int(i == j) for j in range(8)] for i in range(8)], + "Rank-eight certificate") +frame_records = [] +for j in range(8): + support = [p for p, row in zip(labels, roots) if row[j] != 0] + frame = span(support) + require(len(frame) == 256, "Coordinate source rank") + extra = next(p for p in labels if p not in frame) + enlarged = frame | {x ^ extra for x in frame} + require(len(enlarged) == 512, "Frame enlargement") + frame_records.append({"coordinate": j, "support_size": len(support), + "rank": 8, "enlarging_source_label": extra, + "enlarged_rank": 9}) +require(Fraction(8, 9) < Fraction(8, 8), "Exact b=2 counterexample") +pin = "e07a8a3f9f79c22113398a0c5dbbc7601f489b3e" +base = "research/direct-delivery504-global/" +bindings = [] +for name in ["inputs/hamming/PROTOTYPE.json", "NOTICE.md", "SOURCES.json"]: + published = subprocess.check_output(["git", "show", pin + ":" + base + name]) + local = (package / historical / "baseline535/source531" / base / name).read_bytes() + require(local == published, "Pinned source bytes: " + name) + bindings.append({"commit": pin, "path": base + name, + "sha256": sha256(local).hexdigest()}) + +env = os.environ.copy() +env.update(OMP_NUM_THREADS="1", OPENBLAS_NUM_THREADS="1", MKL_NUM_THREADS="1", + VECLIB_MAXIMUM_THREADS="1") +controls = [] + + +def reject(name, command, text): + result = subprocess.run(list(map(str, command)), capture_output=True, + text=True, env=env) + (out / (name + ".stdout.log")).write_text(result.stdout) + (out / (name + ".stderr.log")).write_text(result.stderr) + require(result.returncode != 0, "Control accepted: " + name) + require(text in result.stdout + result.stderr, "Wrong rejection: " + name) + controls.append({"name": name, "command": list(map(str, command)), + "exit_code": result.returncode, "expected_text": text}) + + +reject("optimized-runner", [sys.executable, "-O", "-B", package / "verify.py", + "--build", out / "must-not-create"], + "Run this verifier without -O") +require(not (out / "must-not-create").exists(), "Optimized output was created") +reject("existing-build", [sys.executable, "-B", package / "verify.py", + "--build", out], "The build directory exists.") +scalar = (package / "verify_scalar_lemma.py").read_text() +require(scalar.count('9**7, 8**8') == 1, "Scalar control target") +scalar_path = out / "invalid_scalar.py" +scalar_path.write_text(scalar.replace('9**7, 8**8', '9**8, 8**8')) +for name, option in [("normal", []), ("optimized", ["-O"])]: + reject("invalid-scalar-" + name, + [sys.executable, *option, "-B", scalar_path, out / (name + ".json")], + "positive_critical_point") + +tampered = out / "tampered-package" +shutil.copytree(package, tampered) +changed = json.loads(raw) +changed["root_lines"][0][0] += 1 +(tampered / prototype).write_text(json.dumps(changed)) +reject("manifest-root-drift", [sys.executable, "-B", tampered / "verify.py", + "--build", out / "must-not-create-drift"], + "Source hash:") +require(not (out / "must-not-create-drift").exists(), "Drift output was created") +geometry = tampered / historical / "framework/private64_geometry.py" +reject("geometric-root-drift", [sys.executable, "-B", geometry, + tampered / historical, out / "bad-root.json"], + "AssertionError") +changed = json.loads(raw) +changed["binary_ports"][1] = changed["binary_ports"][0] +(tampered / prototype).write_text(json.dumps(changed)) +reject("geometric-label-drift", [sys.executable, "-B", geometry, + tampered / historical, out / "bad-label.json"], + "AssertionError") + +result = {"status": "PASS_INDEPENDENT_BINDINGS_AND_SEVEN_CONTROLS", + "retained_matrix_dimensions": [112, 8], "gram_dimensions": [112, 112], + "gram_rank_certificate": "R^T R=56 I_8", + "coordinate_frames": frame_records, + "b_equal_2_costs": {"rank8": "1", "rank9": "8/9"}, + "source_bindings": bindings, "controls": controls, + "scope": "Exact fixed source, frame enlargement and rejection controls. The uniform real-variable theorem and the two final profile closures require written proof review."} +(out / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n") +print(result["status"]) diff --git a/research/private-query-concave-range/verify.py b/research/private-query-concave-range/verify.py new file mode 100644 index 0000000000..7c936bf4ce --- /dev/null +++ b/research/private-query-concave-range/verify.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +"""Check the scalar extension and its saved private-query inputs.""" +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + return json.loads(path.read_text()) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + build = args.build.resolve() + require(not build.exists(), "The build directory exists.") + manifest = read(ROOT / "SOURCE-MANIFEST.json") + for item in manifest["files"]: + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + == item["sha256"], "Source hash: " + item["package"]) + build.mkdir(parents=True) + shutil.copytree(ROOT / "historical", build / "historical") + shutil.copytree(ROOT / "independent-review", build / "independent-review") + old = build / "historical/work/autonomous-kappa-run" + stages = [] + def run(name, command, expected=0): + print("Run:", " ".join(map(str, command)), flush=True) + result = subprocess.run(list(map(str, command)), capture_output=True, text=True) + (build / (name + ".stdout.log")).write_text(result.stdout) + (build / (name + ".stderr.log")).write_text(result.stderr) + require(result.returncode == expected, "Exit code: " + name) + stages.append({"name": name, "command": list(map(str, command)), + "exit_code": result.returncode}) + for name, option in [("scalar", []), ("scalar-optimized", ["-O"])]: + run(name, [sys.executable, "-E", *option, "-B", ROOT / "verify_scalar_lemma.py", + build / (name + ".json")]) + require(read(build / (name + ".json"))["status"] == + "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", "Scalar result") + run("scalar-independent", [sys.executable, "-E", "-B", build / + "independent-review/independent_calculation.py"]) + run("geometry", [sys.executable, "-E", "-B", old / "framework/private64_geometry.py", + old, old / "framework/PRIVATE64-GEOMETRY.json"]) + fresh = read(old / "framework/PRIVATE64-GEOMETRY.json") + saved = read(ROOT / "historical/work/autonomous-kappa-run/framework/PRIVATE64-GEOMETRY.json") + for key in saved: + if key not in ["seconds", "source_sha256"]: + require(fresh[key] == saved[key], "Geometry field: " + key) + run("profiles", [sys.executable, "-E", "-B", old / "framework/private64_profiles.py", + old, old / "framework/PRIVATE64-PROFILES.json"]) + fresh_profiles = read(old / "framework/PRIVATE64-PROFILES.json") + saved_profiles = read(ROOT / "historical/work/autonomous-kappa-run/framework/PRIVATE64-PROFILES.json") + for key in saved_profiles: + if key not in ["seconds", "source_sha256"]: + require(fresh_profiles[key] == saved_profiles[key], "Profile field: " + key) + run("rank-nine", [sys.executable, "-E", "-B", old / + "framework/private64-weighted/independent_max_rank.py", + build / "rank-nine.json"]) + rank_nine = read(build / "rank-nine.json") + require(rank_nine["status"] == "PASS_INDEPENDENT_WEIGHTED_RANK_NINE_EXCLUSION", + "Rank-nine result") + receipt = {"status": "PASS_PRIVATE_QUERY_CONCAVE_RANGE_INPUTS", "stages": stages, + "scalar_margin": read(build / "scalar.json")["strict_gap_lower"], + "rank7_frames": fresh["rank7_planes"], + "profiles_through_63": fresh_profiles["profile_counts"]["all"], + "total64_partitions": rank_nine["partitions"], + "rank9_partitions": rank_nine["rank_nine_partitions"], + "scope": "Finite proof inputs only. The written real-variable argument, capacity bounds and two query-profile closures are required. No fitting-rigidity or physical supplier replay.", + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest()} + (build / "receipt.json").write_text(json.dumps(receipt, indent=2) + "\n") + print(receipt["status"], receipt["scalar_margin"], receipt["profiles_through_63"]) + + +if __name__ == "__main__": + main() diff --git a/research/private-query-concave-range/verify_scalar_lemma.py b/research/private-query-concave-range/verify_scalar_lemma.py new file mode 100644 index 0000000000..dffd4363a4 --- /dev/null +++ b/research/private-query-concave-range/verify_scalar_lemma.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Check exact inputs to the uniform private-cost bound. + +Use integer arithmetic and rational arithmetic. Do not import a price +engine. Prepared with OpenAI Codex assistance; Apache-2.0. +""" +from fractions import Fraction +from hashlib import sha256 +import json +from pathlib import Path +import sys +import time + + +def verify(): + pairs = ( + ("positive_critical_point", 9**7, 8**8), + ("critical_log_ratio", 8**96, 9**91), + ("critical_point_below_seven_tenths", 13**10 * 8**7, + 12**10 * 9**7), + ("minimum_coefficient_below_four_ninths", 9**17, 8**18), + ("power_below_thirteen_thirds", 8**7 * 3**10, 13**10), + ) + for name, left, right in pairs: + if not left < right: + raise ValueError(name) + margin = 2 - Fraction(4, 9) * Fraction(13, 3) + if margin != Fraction(2, 27) or margin <= 0: + raise ValueError("margin") + # Sum the chord at q=65 and N=9 as a polynomial in x=9^a. + slope = (Fraction(-1, 8), Fraction(1, 8)) + intercept = (Fraction(9, 8), Fraction(-1, 8)) + coefficients = tuple(65 * slope[i] + 9 * intercept[i] + for i in range(2)) + if coefficients != (2, 7): + raise ValueError("chord") + if 7 + 2 - 8 != 1 or 7 * 9 + 2 - 8 * 8 != 1: + raise ValueError("endpoints") + return pairs, margin + + +def main(): + start = time.monotonic() + output = Path(sys.argv[1]).resolve() + if output.exists(): + raise ValueError("The output file exists.") + pairs, margin = verify() + script = Path(__file__).resolve() + report = { + "status": "PASS_EXACT_FULL_CONCAVE_PRIVATE_COST_LEMMA", + "strict_gap_lower": str(margin), + "integer_comparisons": [ + {"name": name, "left": str(left), "right": str(right), + "positive_gap": str(right - left)} + for name, left, right in pairs + ], + "chord_at_rank_total_65_query_count_9": [2, 7], + "assumptions_not_replayed": [ + "Fixed Gram code has rank eight and minimum support 53.", + "Source-frame ranks are one through nine.", + "Rank-seven source capacity is at most 36.", + "Total private frame rank is at least 64.", + "Total-64 feasible profiles have no rank-nine frame.", + "Eight rank-eight coordinate gathers factor the Gram code." + ], + "script_sha256": sha256(script.read_bytes()).hexdigest(), + "proof_sha256": sha256(script.with_name("PROOF.md").read_bytes()).hexdigest(), + "seconds": time.monotonic() - start, + } + output.write_text(json.dumps(report, indent=2) + "\n") + print(report["status"], report["strict_gap_lower"]) + + +if __name__ == "__main__": + main()