diff --git a/research/binary-c5-total-seven-orbits/README.md b/research/binary-c5-total-seven-orbits/README.md new file mode 100644 index 0000000000..af183f5b91 --- /dev/null +++ b/research/binary-c5-total-seven-orbits/README.md @@ -0,0 +1,182 @@ +# Binary C5 fitting matrices at total payload seven + +This contribution is produced by Nick Petalas. Claim type: **finite +classification certificate**, with a written completeness argument. Apache-2.0. + +There are exactly **1, 51 and 6 local-similarity classes** of rank-optimal +binary fitting matrices for the three positive total-seven C5 width profiles. +Only 1, 5 and 2 classes, respectively, have integral edge/private-channel +form. Thus 50 of the 58 classes across these three representative profiles +lie outside that form. Every class has an explicit canonical representative +in [RESULT.json](RESULT.json). + +| Width profile | All legal matrices | Rank-four matrices | Local classes | Edge/private classes | Other classes | +|---|---:|---:|---:|---:|---:| +| (3,1,1,1,1) | 262,144 | 168 | 1 | 1 | 0 | +| (2,2,1,1,1) | 1,048,576 | 1,332 | 51 | 5 | 46 | +| (2,1,2,1,1) | 262,144 | 216 | 6 | 2 | 4 | + +This answers the binary part of the total-seven classification question +explicitly left by JoyboyBrian's [#5215](https://github.com/CrocSwap/integer-mult-bounds/pull/5215). +That predecessor proves half-total rigidity over every field and supplies a +rational noncanonical total-seven example. It does not classify this binary +domain. Its results and JoyboyBrian's rank formula in +[#5023](https://github.com/CrocSwap/integer-mult-bounds/pull/5023) are cited, +without running their verifiers or recounting their domains. + +## Exact domain and equivalence + +Vertices 0 through 4 are labeled in cyclic order. Vertex i has positive +width d_i, with total seven. A fitting matrix M over F2 has diagonal blocks +I_(d_i), and both ordered off-diagonal blocks vanish at every nonedge. +Neighbor blocks are arbitrary, possibly rectangular and nonsymmetric. + +Two fits are equivalent exactly when M'=L M L^-1 for block-diagonal L with +one independent GL_(d_i)(F2) block at each vertex. This is similarity, not +independent changes of row and column bases. Vertex permutations and +transposition are not included. Rotation/reflection sends every positive +total-seven width vector to one of the three displayed profiles, so these +cover all width patterns. The table does not also identify classes under +the automorphisms of each profile. + +An integral edge/private form has x_i shared channels on edge (i,i+1) and +p_i private channels at vertex i, with x_(i-1)+x_i+p_i=d_i. Each shared +channel contributes an all-ones 2-by-2 matrix on its endpoint coordinates; +each private channel contributes [1]. Its rank is 7-sum(x_i), including over +F2. Rank-four forms therefore have sum(x_i)=3. Every nonnegative integral +choice and every local conjugate of each choice are included. + +## Why the certificate is complete + +The primary enumerator visits every assignment to the 18, 20 or 18 free +binary entries exactly once in reflected Gray order. Highest-pivot row +elimination gives these complete rank histograms, in order of ranks 0 to 7: + +```text +(3,1,1,1,1): 0 0 0 0 168 18264 146784 96928 +(2,2,1,1,1): 0 0 0 0 1332 85716 593688 367840 +(2,1,2,1,1): 0 0 0 0 216 19368 147232 95328 +``` + +The local group orders are 168, 36 and 36. Elementary additions I+E_ab +within a vertex generate its full binary general linear group. Gaussian +elimination proves this: no nontrivial scalar rescaling is needed over F2, +and a row interchange is three elementary additions. Starting with an +unclassified rank-four fit, the primary enumerator takes its full generator +orbit and removes it from the remaining set. Each generated matrix must +belong to that remaining set. Thus the resulting orbits are exhaustive and +disjoint, rather than sampled. + +A representative is the least 49-bit row-major word in its orbit, with +word=sum_i(row_i*2^(7i)) and bit j in row_i equal to M_ij. RESULT.json records +its seven row integers, orbit size, stabilizer size and channel label. +The orbit-size histograms are {168:1}, {6:6,18:18,36:27}, and {36:6}. +Their weighted sums recover 168, 1,332 and 216 matrices. + +All channel multiplicities with sum(x_i)=3 and nonnegative p_i are +enumerated. Local coordinate permutations send every placement of those +channels to the chosen standard placement. Conversely local similarity +preserves ordered block ranks, so distinct edge multiplicities cannot +become equivalent. Orbit membership therefore decides channel equivalence +exactly, including for nonsymmetric fits. + +The independent verifier uses different enumeration, rank and orbit methods. +It takes a Cartesian product of complete row choices, intersects precomputed +annihilator sets of all 128 binary vectors, and derives rank from the kernel +cardinality. It enumerates every local invertible matrix by the determinant +formula and applies the entire product group. Every representative must be +canonical, the orbits must be disjoint, and their union must equal the +independently enumerated optimum set. A separately placed channel constructor +checks every edge/private label. No predecessor executable is imported. + +For example, rows [73,6,6,9,48,48,64] give the first nonchannel representative +for (2,2,1,1,1). Its orbit has 18 matrices and stabilizer order two. It and +all 57 other representatives are part of the complete replay. + +Eight corrupted certificates must reject. They change a rank histogram +while preserving its total, omit or duplicate an orbit, corrupt a +representative, change an orbit size or group order, erase a channel label, +or omit a profile. Another 7,200 checks compare bit operations with literal +entry-array conjugation and confirm elementary additions are involutions. +Complete-group orbits are also compared directly with generator orbits. + +## Reproduction + +From the repository root, with CPython 3.12 and the standard library only: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B scripts/research_package.py --package research/binary-c5-total-seven-orbits +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/binary-c5-total-seven-orbits/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/binary-c5-total-seven-orbits/independent.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/binary-c5-total-seven-orbits/controls.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/binary-c5-total-seven-orbits --check-source-history +``` + +Any CPython 3.12 installation can replace the local interpreter path. +Expected markers are PASS_BINARY_C5_TOTAL_SEVEN_ORBITS, +PASS_BINARY_C5_INDEPENDENT_KERNEL_AND_FULL_GROUP and PASS_BINARY_C5_CONTROLS. +The primary verifier prints the SHA256 of the canonical classification. +Its optional --receipt PATH writes a generated receipt containing package +file hashes, the actual interpreter, platform and elapsed time. Choose a +path outside the checkout. Registered commands produce no checkout artifacts. + +## Limits and engineering checks + +This is a complete **finite binary** classification for the exact domain +above. It is not an all-field classification or proof-kernel verification. +No native decoder, paid basis changes, reads/copies, dirty restoration, +ownership/hosting, preparation, stock/precision, tape, compiler or complete +consumer is supplied. No multiplication theorem, new kappa or selected +frontier change follows. No Lean, Docker or selected cold replay ran. + +All loops have finite domain bounds: at most 2^20 matrices per profile, +seven rows per matrix operation, 168 members per orbit, 512 candidate local +GL matrices, and 4^5 channel choices. The primary stores at most 2^20 optimum +words; the largest actual set has 1,332. Independent vector tables have +128 entries per group element. There is no recursion, background process, +network use or predecessor import. Functions stay below 60 physical lines. +Explicit exceptions enforce invariants under normal and optimized Python. + +Power of Ten rule 3 has a managed-runtime deviation in the four Python +files. Integer, set and list operations allocate dynamically; the fixed +seven-coordinate domain bounds all live collections. No fixed-allocation +or interpreter-allocation claim is made. A native port would need +fixed-capacity buffers before making that stronger claim. Rule 10 uses +warning-strict normal/optimized replay and the available static checks; +this does not establish a repository-wide static-analysis policy. Other +inspections found direct finite call paths, local state, checked results, +no metaprogramming and no intended additional deviations. + +## Open next questions + +- Classify the same profiles over larger finite fields or symbolically. + This would separate field-specific orbit splitting from general odd-total + geometry. Start with F3 and the one width-three profile. This binary + enumeration supplies no universal normal form or bound on parameters. +- Determine whether a nonchannel class supports a useful source-compatible + decoder. Start with a literal producer/consumer mask and one explicit + representative. Paid basis changes, queries, restoration and a complete + physical caller are missing; rank four alone is no price certificate. + +Structured questions and blockers are in [TASK.json](TASK.json). + +## Sources and credit + +The base is canonical main de5ec2e7a6074068452f45b1a191b5c72832df4a, +priority revision 8. [SOURCES.json](SOURCES.json) pins predecessor documents +as provenance. The computation imports none of them. The +[advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19214456) +states this finite scope. Live PRs and handoffs, recent account PRs, local +reservations, all-main README searches and merged-PR searches were checked. +The cached scan covered 416 open PRs and 5,307 Discussion records, with +incomplete sparse local-note coverage. These searches do not cover +unpublished work or establish global literature priority. + +Credit JoyboyBrian #5215 for the explicit question and #5023 for the rank +capacity theorem; Nick Petalas #5180 and #3248 for earlier rigidity and +equality arguments; Tekalign #3362, Sagar Thakrar #2484/#3232, ywz65 #2471, +Cinna Davis, Adam Gall, ctoth, Philippe Van Velzen and the retained +P112/query-mask lineage for the preceding interfaces. Gaussian elimination, +orbit-stabilizer counting and finite general linear groups are classical. +The new finite classification and standalone verifiers are produced by +Nick Petalas. Independent human and formal proof-kernel review are unclaimed. diff --git a/research/binary-c5-total-seven-orbits/RESULT.json b/research/binary-c5-total-seven-orbits/RESULT.json new file mode 100644 index 0000000000..fec8c4748d --- /dev/null +++ b/research/binary-c5-total-seven-orbits/RESULT.json @@ -0,0 +1,1033 @@ +{ + "equivalence": "block-diagonal similarity; labeled vertices", + "field": "F2", + "profiles": [ + { + "edge_private_orbits": 1, + "free_entries": 18, + "local_group_order": 168, + "matrix_count": 262144, + "minimum_rank": 4, + "optimal_matrices": 168, + "orbit_count": 1, + "orbit_size_histogram": { + "168": 1 + }, + "orbits": [ + { + "edge_private_form": { + "private": [ + 1, + 0, + 0, + 0, + 0 + ], + "shared": [ + 1, + 0, + 1, + 0, + 1 + ] + }, + "orbit_size": 168, + "representative_rows": [ + 65, + 10, + 4, + 10, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + } + ], + "rank_histogram": [ + 0, + 0, + 0, + 0, + 168, + 18264, + 146784, + 96928 + ], + "widths": [ + 3, + 1, + 1, + 1, + 1 + ] + }, + { + "edge_private_orbits": 5, + "free_entries": 20, + "local_group_order": 36, + "matrix_count": 1048576, + "minimum_rank": 4, + "optimal_matrices": 1332, + "orbit_count": 51, + "orbit_size_histogram": { + "6": 6, + "18": 18, + "36": 27 + }, + "orbits": [ + { + "edge_private_form": { + "private": [ + 0, + 0, + 0, + 0, + 1 + ], + "shared": [ + 2, + 0, + 1, + 0, + 0 + ] + }, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 48, + 64 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 73, + 6, + 6, + 9, + 48, + 48, + 64 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 112, + 64 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 73, + 6, + 6, + 9, + 48, + 112, + 64 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": { + "private": [ + 0, + 0, + 0, + 1, + 0 + ], + "shared": [ + 1, + 1, + 0, + 0, + 1 + ] + }, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 20, + 32, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 52, + 32, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 20, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": { + "private": [ + 0, + 1, + 0, + 0, + 0 + ], + "shared": [ + 1, + 0, + 1, + 0, + 1 + ] + }, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 6, + 8, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 73, + 6, + 6, + 8, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 48, + 65 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 6, + 9, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 78, + 6, + 9, + 48, + 48, + 65 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 21, + 10, + 48, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 4, + 10, + 52, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 69, + 10, + 4, + 10, + 52, + 48, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 20, + 96, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 21, + 10, + 52, + 96, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 20, + 112, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 5, + 10, + 5, + 10, + 52, + 112, + 65 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 5, + 10, + 52, + 112, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 5, + 78, + 5, + 10, + 52, + 112, + 65 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 48, + 96 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 70, + 22, + 9, + 48, + 48, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": { + "private": [ + 0, + 0, + 1, + 0, + 0 + ], + "shared": [ + 2, + 0, + 0, + 1, + 0 + ] + }, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 16, + 96, + 96 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 22, + 9, + 16, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 6, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": { + "private": [ + 1, + 0, + 0, + 0, + 0 + ], + "shared": [ + 1, + 1, + 0, + 1, + 0 + ] + }, + "orbit_size": 36, + "representative_rows": [ + 9, + 2, + 20, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 9, + 6, + 20, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 9, + 66, + 20, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 9, + 70, + 20, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 9, + 2, + 22, + 9, + 20, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 13, + 6, + 6, + 25, + 20, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 96, + 96 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 70, + 22, + 9, + 48, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 6, + 9, + 52, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 9, + 66, + 22, + 9, + 52, + 96, + 96 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 77, + 6, + 6, + 25, + 52, + 96, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 6, + "representative_rows": [ + 9, + 6, + 6, + 9, + 16, + 112, + 96 + ], + "stabilizer_size": 6 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 22, + 9, + 16, + 112, + 96 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 20, + 32, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 10, + 20, + 10, + 52, + 32, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 69, + 10, + 20, + 10, + 20, + 48, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 6, + 6, + 9, + 48, + 48, + 97 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 9, + 78, + 22, + 9, + 48, + 48, + 97 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 69, + 10, + 20, + 10, + 48, + 48, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 1, + 10, + 20, + 10, + 20, + 96, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 1, + 10, + 21, + 10, + 20, + 96, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 5, + 10, + 5, + 10, + 20, + 112, + 97 + ], + "stabilizer_size": 2 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 5, + 10, + 20, + 10, + 20, + 112, + 97 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 18, + "representative_rows": [ + 5, + 14, + 5, + 26, + 20, + 112, + 97 + ], + "stabilizer_size": 2 + } + ], + "rank_histogram": [ + 0, + 0, + 0, + 0, + 1332, + 85716, + 593688, + 367840 + ], + "widths": [ + 2, + 2, + 1, + 1, + 1 + ] + }, + { + "edge_private_orbits": 2, + "free_entries": 18, + "local_group_order": 36, + "matrix_count": 262144, + "minimum_rank": 4, + "optimal_matrices": 216, + "orbit_count": 6, + "orbit_size_histogram": { + "36": 6 + }, + "orbits": [ + { + "edge_private_form": { + "private": [ + 0, + 0, + 1, + 0, + 0 + ], + "shared": [ + 1, + 0, + 1, + 0, + 1 + ] + }, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 6, + 40, + 16, + 40, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 22, + 40, + 16, + 40, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 6, + 40, + 20, + 40, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": { + "private": [ + 1, + 0, + 0, + 0, + 0 + ], + "shared": [ + 0, + 1, + 1, + 0, + 1 + ] + }, + "orbit_size": 36, + "representative_rows": [ + 65, + 2, + 20, + 40, + 20, + 40, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 6, + 20, + 40, + 20, + 40, + 65 + ], + "stabilizer_size": 1 + }, + { + "edge_private_form": null, + "orbit_size": 36, + "representative_rows": [ + 65, + 2, + 22, + 40, + 20, + 40, + 65 + ], + "stabilizer_size": 1 + } + ], + "rank_histogram": [ + 0, + 0, + 0, + 0, + 216, + 19368, + 147232, + 95328 + ], + "widths": [ + 2, + 1, + 2, + 1, + 1 + ] + } + ] +} diff --git a/research/binary-c5-total-seven-orbits/SOURCES.json b/research/binary-c5-total-seven-orbits/SOURCES.json new file mode 100644 index 0000000000..4d2322b844 --- /dev/null +++ b/research/binary-c5-total-seven-orbits/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/unequal-cycle-fit-rigidity-boundary/PROOF.md", + "usage": "provenance", + "git_blob": "45f9d227a90550ca5eb07cdf6055a7d9f7589545", + "sha256": "070a983b3004e63ec178093c161ca3e599d54c6a0930728c6ae385a44060f3bd" + }, + { + "path": "research/odd-cycle-query-capacity/PROOF.md", + "usage": "provenance", + "git_blob": "5130e487b8f4e7c3f49cd4a654fe3fc51ce900b5", + "sha256": "fc99f405abd5df1c3f88563826f02b53783bba464d1a1852b5093126bf42637a" + }, + { + "path": "research/odd-cycle-fit-rigidity/PROOF.md", + "usage": "provenance", + "git_blob": "e8cc272d30d0f6e78db67865a4f4b1195f8d78d1", + "sha256": "a532f16fd77bc5b0c4834766461b8cf445b5ec9adf0d985107b7ef052a1e4f04" + } + ] +} diff --git a/research/binary-c5-total-seven-orbits/TASK.json b/research/binary-c5-total-seven-orbits/TASK.json new file mode 100644 index 0000000000..9402c1210c --- /dev/null +++ b/research/binary-c5-total-seven-orbits/TASK.json @@ -0,0 +1,82 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 8, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a legal decoder or coframe change improve the full signed moment, including changed helper targets?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Price one complete changed itinerary with both paid and productive histograms. Check #5693/#5698 for overlap and their exact hypotheses before another coframe search. Use the signed invoice preflight where its boundary contract agrees; an inconclusive concave comparison is not a power crossing. Stop if an optimistic complete budget fails at the chosen target or native delivery remains unspecified.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "coframe", + "signed moment", + "5693", + "5698" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Complete finite local-similarity classification of binary rank-optimal C5 fitting matrices in the three positive total-seven width profiles.", + "scope_change_reason": "Algebraic side result answering the explicit total-seven question in JoyboyBrian #5215; this does not implement the card's changed complete supplier or signed moment.", + "bottleneck_link": "Side result: exposes which optimal binary decoder masks need more than integral edge/private channels. Physical consumer and complete paid cost remain unknown.", + "budget_minutes": 60, + "stop_rule": "Stop after the first complete binary classification and bounded independent replay; leave larger fields and physical lowering open.", + "outcome": "completed", + "evidence": "RESULT.json: 1,51,6 local orbits; 1,5,2 edge/private orbits. Primary enumeration, independent kernel/full-group enumeration and eight corruption controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Classify positive total-seven C5 optima over larger fields or symbolically.", + "why_it_matters": "Distinguishes field-specific orbit splitting from general odd-total geometry.", + "first_step": "Enumerate F3 fits for the (3,1,1,1,1) profile, or derive algebraic invariants before enumeration.", + "blocked_by": "The binary finite certificate supplies no universal normal form or parameter bound." + }, + { + "question": "Can one nonchannel class support an affordable actual decoder?", + "why_it_matters": "Algebraic rank four does not price a supplier or prove native legality.", + "first_step": "Bind a literal producer/consumer read mask to one recorded representative and price its complete basis/query/cleanup schedule.", + "blocked_by": "No actual caller, physical basis conversion, restoration or complete cost is supplied." + } + ], + "claim_type": "finite-classification-certificate" +} diff --git a/research/binary-c5-total-seven-orbits/VERIFY.json b/research/binary-c5-total-seven-orbits/VERIFY.json new file mode 100644 index 0000000000..7406381930 --- /dev/null +++ b/research/binary-c5-total-seven-orbits/VERIFY.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Every legal binary fit, full generator-orbit partition and all channel labels." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 120, + "checks": "Independent row-product/kernel census and determinant-enumerated full local-group classification." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/controls.py" + ], + "timeout_seconds": 120, + "checks": "Eight corrupted certificate rejections and 7200 literal conjugation/involution controls." + } + ] +} diff --git a/research/binary-c5-total-seven-orbits/census.py b/research/binary-c5-total-seven-orbits/census.py new file mode 100644 index 0000000000..0cee4f7020 --- /dev/null +++ b/research/binary-c5-total-seven-orbits/census.py @@ -0,0 +1,190 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Complete finite classification over F_2; produced by Nick Petalas.""" + +from collections import Counter +from itertools import product + +PROFILES = ((3, 1, 1, 1, 1), (2, 2, 1, 1, 1), (2, 1, 2, 1, 1)) +N = 7 +MASK = (1 << N) - 1 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def layout(widths): + require(tuple(widths) in PROFILES, "unsupported width profile") + owners = tuple(i for i, d in enumerate(widths) for _ in range(d)) + positions = tuple( + N * a + b for a in range(N) for b in range(N) + if (owners[a] - owners[b]) % 5 in (1, 4) + ) + generators = tuple( + (a, b) for a in range(N) for b in range(N) + if a != b and owners[a] == owners[b] + ) + identity = sum(1 << (N * a + a) for a in range(N)) + return owners, positions, generators, identity + + +def rank(word): + """Row elimination using highest-set-bit pivots.""" + pivots = [0] * N + answer = 0 + for i in range(N): + row = (word >> (N * i)) & MASK + for _ in range(N): + if not row: + break + j = row.bit_length() - 1 + if pivots[j]: + row ^= pivots[j] + else: + pivots[j] = row + answer += 1 + break + return answer + + +def image_rank(word): + """Independent rank: enumerate the complete column image.""" + image = {0} + for j in range(N): + column = sum(((word >> (N * i + j)) & 1) << i for i in range(N)) + image |= {value ^ column for value in image} + require(len(image) & (len(image) - 1) == 0, "image not a binary space") + return len(image).bit_length() - 1 + + +def conjugate(word, a, b): + """Conjugate by I+E_ab, whose inverse is itself in F_2.""" + word ^= ((word >> (N * b)) & MASK) << (N * a) + column_mask = sum(1 << (N * i + a) for i in range(N)) + column = word & column_mask + word ^= column << (b - a) if b > a else column >> (a - b) + return word + + +def dense_conjugate(word, a, b): + """Independent entry-array implementation of the same matrix product.""" + entries = [[(word >> (N * i + j)) & 1 for j in range(N)] for i in range(N)] + entries[a] = [x ^ y for x, y in zip(entries[a], entries[b])] + for i in range(N): + entries[i][b] ^= entries[i][a] + return sum(entries[i][j] << (N * i + j) for i in range(N) for j in range(N)) + + +def orbit(word, generators, group_order): + reached = {word} + pending = [word] + for cursor in range(group_order): + if cursor == len(pending): + break + current = pending[cursor] + for a, b in generators: + neighbor = conjugate(current, a, b) + if neighbor not in reached: + reached.add(neighbor) + pending.append(neighbor) + require(len(reached) <= group_order, "orbit exceeds local group") + require(len(pending) == len(reached), "orbit worklist mismatch") + require(all(conjugate(x, a, b) in reached for x in reached for a, b in generators), + "incomplete orbit") + return reached + + +def group_size(widths): + answer = 1 + for d in widths: + for j in range(d): + answer *= (1 << d) - (1 << j) + return answer + + +def enumerate_fits(widths): + _, positions, _, word = layout(widths) + histogram = [0] * (N + 1) + optima = set() + for index in range(1 << len(positions)): + if index: + changed = (index & -index).bit_length() - 1 + word ^= 1 << positions[changed] + r = rank(word) + histogram[r] += 1 + if r == 4: + optima.add(word) + require(sum(histogram) == 1 << len(positions), "enumeration count mismatch") + require(not any(histogram[:4]), "rank below cited lower bound") + require(bool(optima), "no rank-four attainer") + return histogram, optima + + +def edge_forms(widths): + _, _, _, identity = layout(widths) + offsets = [sum(widths[:i]) for i in range(5)] + forms = {} + for shared in product(range(4), repeat=5): + if sum(shared) != 3: + continue + private = tuple(widths[i] - shared[i - 1] - shared[i] for i in range(5)) + if min(private) < 0: + continue + word = identity + for i in range(5): + j = (i + 1) % 5 + for k in range(shared[i]): + a = offsets[i] + shared[i - 1] + k + b = offsets[j] + k + word |= (1 << (N * a + b)) | (1 << (N * b + a)) + require(rank(word) == 4, "edge form has wrong rank") + forms[word] = {"shared": list(shared), "private": list(private)} + return forms + + +def profile_census(widths): + _, positions, generators, identity = layout(widths) + histogram, optima = enumerate_fits(widths) + order = group_size(widths) + channel_forms = edge_forms(widths) + unseen = set(optima) + records = [] + for _ in range(len(optima)): + if not unseen: + break + members = orbit(min(unseen), generators, order) + require(members <= unseen, "orbit crosses an earlier class or leaves optima") + representative = min(members) + require(image_rank(representative) == 4, "independent image rank mismatch") + require(all(conjugate(representative, a, b) == + dense_conjugate(representative, a, b) for a, b in generators), + "independent conjugation mismatch") + forms = [value for key, value in channel_forms.items() if key in members] + require(len(forms) <= 1, "distinct channel multiplicities in one orbit") + records.append({ + "representative_rows": [(representative >> (N * i)) & MASK for i in range(N)], + "orbit_size": len(members), "stabilizer_size": order // len(members), + "edge_private_form": forms[0] if forms else None, + }) + unseen.difference_update(members) + require(not unseen, "unclassified optima") + require(sum(record["orbit_size"] for record in records) == len(optima), + "orbit sizes do not partition optima") + for word in optima: + require(image_rank(word) == 4, "independent optimum-rank disagreement") + sizes = Counter(record["orbit_size"] for record in records) + return { + "widths": list(widths), "free_entries": len(positions), + "matrix_count": 1 << len(positions), "rank_histogram": histogram, + "minimum_rank": 4, "optimal_matrices": len(optima), "local_group_order": order, + "orbit_count": len(records), + "orbit_size_histogram": {str(key): value for key, value in sorted(sizes.items())}, + "edge_private_orbits": sum(x["edge_private_form"] is not None for x in records), + "orbits": records, + } + + +def run_census(): + return {"field": "F2", "equivalence": "block-diagonal similarity; labeled vertices", + "profiles": [profile_census(widths) for widths in PROFILES]} diff --git a/research/binary-c5-total-seven-orbits/controls.py b/research/binary-c5-total-seven-orbits/controls.py new file mode 100644 index 0000000000..bc9a7eb7cd --- /dev/null +++ b/research/binary-c5-total-seven-orbits/controls.py @@ -0,0 +1,77 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Reject corrupted scientific certificates; produced by Nick Petalas.""" + +from copy import deepcopy +import json +from pathlib import Path + +from census import PROFILES, conjugate, dense_conjugate, layout, orbit, rank, require +from independent import full_group, transform, verify_certificate + + +def expect_rejection(certificate, label): + try: + verify_certificate(certificate) + except (ValueError, KeyError, TypeError): + return + raise ValueError("accepted corrupted certificate: " + label) + + +def controls(): + saved = json.loads((Path(__file__).parent / "RESULT.json").read_text()) + mutations = [] + changed = deepcopy(saved) + changed["profiles"][0]["rank_histogram"][4] -= 1 + changed["profiles"][0]["rank_histogram"][5] += 1 + mutations.append((changed, "rank histogram with unchanged total")) + changed = deepcopy(saved) + changed["profiles"][1]["orbits"].pop() + mutations.append((changed, "missing orbit")) + changed = deepcopy(saved) + changed["profiles"][2]["orbits"].append(changed["profiles"][2]["orbits"][0]) + mutations.append((changed, "duplicate orbit")) + changed = deepcopy(saved) + changed["profiles"][0]["orbits"][0]["representative_rows"][0] = 0 + mutations.append((changed, "invalid representative")) + changed = deepcopy(saved) + changed["profiles"][1]["orbits"][0]["orbit_size"] += 1 + mutations.append((changed, "wrong orbit size")) + changed = deepcopy(saved) + changed["profiles"][0]["orbits"][0]["edge_private_form"] = None + mutations.append((changed, "incorrect channel classification")) + changed = deepcopy(saved) + changed["profiles"][2]["local_group_order"] += 1 + mutations.append((changed, "wrong full local group")) + changed = deepcopy(saved) + changed["profiles"].pop() + mutations.append((changed, "omitted width profile")) + for changed, label in mutations: + expect_rejection(changed, label) + return len(mutations) + + +def action_controls(): + saved = json.loads((Path(__file__).parent / "RESULT.json").read_text()) + checked = 0 + require(rank(0) == 0 and rank((1 << 49) - 1) == 1, "rank boundary controls") + for widths, record in zip(PROFILES, saved["profiles"]): + _, _, generators, identity = layout(widths) + require(rank(identity) == 7, "identity rank") + group = full_group(widths) + for item in record["orbits"]: + word = sum(row << (7 * i) for i, row in enumerate(item["representative_rows"])) + generated = orbit(word, generators, len(group)) + require(generated == {transform(word, element) for element in group}, + "generators do not cover complete group orbit") + for member in generated: + for a, b in generators: + result = conjugate(member, a, b) + require(result == dense_conjugate(member, a, b), "dense action mismatch") + require(conjugate(result, a, b) == member, "transvection not involutive") + checked += 1 + return checked + + +if __name__ == "__main__": + print("PASS_BINARY_C5_CONTROLS", {"rejected_certificates": controls(), + "dense_action_checks": action_controls()}) diff --git a/research/binary-c5-total-seven-orbits/independent.py b/research/binary-c5-total-seven-orbits/independent.py new file mode 100644 index 0000000000..8f478472a6 --- /dev/null +++ b/research/binary-c5-total-seven-orbits/independent.py @@ -0,0 +1,165 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent kernel census and full-group replay; produced by Nick Petalas.""" + +from itertools import permutations, product + +PROFILES = ((3, 1, 1, 1, 1), (2, 2, 1, 1, 1), (2, 1, 2, 1, 1)) + + +def check(condition, message): + if not condition: + raise ValueError(message) + + +def direct_census(widths): + """Enumerate row choices directly and intersect all annihilator sets.""" + owners = [vertex for vertex in range(5) for _ in range(widths[vertex])] + row_options = [] + for i in range(7): + allowed = sum(1 << j for j in range(7) + if (owners[i] - owners[j]) % 5 in (1, 4)) + row_options.append(tuple((1 << i) | x for x in range(128) if x & ~allowed == 0)) + annihilators = tuple(sum(1 << x for x in range(128) + if (x & row).bit_count() % 2 == 0) for row in range(128)) + histogram = [0] * 8 + optima = set() + for rows in product(*row_options): + kernel = (1 << 128) - 1 + for row in rows: + kernel &= annihilators[row] + cardinality = kernel.bit_count() + check(cardinality > 0 and cardinality & (cardinality - 1) == 0, + "kernel cardinality is not a power of two") + rank = 7 - (cardinality.bit_length() - 1) + histogram[rank] += 1 + if rank == 4: + optima.add(sum(row << (7 * i) for i, row in enumerate(rows))) + return histogram, optima + + +def general_linear(d): + """List all invertible local matrices by the determinant formula.""" + choices = [] + for rows in product(range(1 << d), repeat=d): + determinant = 0 + for perm in permutations(range(d)): + term = 1 + for i in range(d): + term &= (rows[i] >> perm[i]) & 1 + determinant ^= term + if determinant: + choices.append(rows) + return choices + + +def full_group(widths): + """Return the complete vector permutations L and L^-1.""" + elements = [] + for blocks in product(*(general_linear(d) for d in widths)): + rows = [] + offset = 0 + for block in blocks: + rows.extend(row << offset for row in block) + offset += len(block) + forward = tuple(sum(((row & x).bit_count() % 2) << i + for i, row in enumerate(rows)) for x in range(128)) + check(len(set(forward)) == 128, "singular local group element") + inverse = [0] * 128 + for x, y in enumerate(forward): + inverse[y] = x + elements.append((forward, tuple(inverse))) + return elements + + +def transform(word, element): + forward, inverse = element + columns = tuple(sum(((word >> (7 * i + j)) & 1) << i for i in range(7)) + for j in range(7)) + answer = 0 + for j in range(7): + image = 0 + for k in range(7): + if inverse[1 << j] & (1 << k): + image ^= columns[k] + column = forward[image] + for i in range(7): + answer |= ((column >> i) & 1) << (7 * i + j) + return answer + + +def independent_channels(widths): + """Build every optimal edge/private word with separate port allocation.""" + offsets = [sum(widths[:i]) for i in range(5)] + forms = {} + for x in product(*(range(min(widths[i], widths[(i + 1) % 5]) + 1) + for i in range(5))): + private = [widths[i] - x[i - 1] - x[i] for i in range(5)] + if sum(x) != 3 or min(private) < 0: + continue + next_port = offsets[:] + rows = [1 << i for i in range(7)] + for i in range(5): + j = (i + 1) % 5 + for _ in range(x[i]): + a, b = next_port[i], next_port[j] + next_port[i] += 1 + next_port[j] += 1 + rows[a] |= 1 << b + rows[b] |= 1 << a + word = sum(row << (7 * i) for i, row in enumerate(rows)) + forms[word] = {"shared": list(x), "private": private} + return forms + + +def verify_profile(record): + widths = tuple(record["widths"]) + check(widths in PROFILES, "unexpected profile") + histogram, optima = direct_census(widths) + check(histogram == record["rank_histogram"], "independent rank histogram") + check(len(optima) == record["optimal_matrices"], "independent optimum count") + elements = full_group(widths) + check(len(elements) == record["local_group_order"], "independent group order") + channels = independent_channels(widths) + covered = set() + sizes = {} + for orbit in record["orbits"]: + word = sum(row << (7 * i) for i, row in enumerate(orbit["representative_rows"])) + check(word in optima, "invalid orbit representative") + members = {transform(word, element) for element in elements} + check(min(members) == word, "noncanonical orbit representative") + check(members <= optima and not members & covered, "overlapping or invalid orbit") + check(len(members) == orbit["orbit_size"], "independent orbit size") + check(len(elements) == len(members) * orbit["stabilizer_size"], "stabilizer count") + forms = [value for key, value in channels.items() if key in members] + check(forms == ([] if orbit["edge_private_form"] is None else + [orbit["edge_private_form"]]), "independent channel classification") + covered.update(members) + size = str(len(members)) + sizes[size] = sizes.get(size, 0) + 1 + check(covered == optima, "orbit partition omits an optimum") + check(len(record["orbits"]) == record["orbit_count"], "orbit count") + check(sizes == record["orbit_size_histogram"], "orbit-size histogram") + check(sum(x["edge_private_form"] is not None for x in record["orbits"]) == + record["edge_private_orbits"], "edge/private count") + check(sum(histogram) == record["matrix_count"] == 1 << record["free_entries"], + "complete matrix count") + check(record["minimum_rank"] == next(i for i, count in enumerate(histogram) if count), + "minimum rank") + + +def verify_certificate(certificate): + check(certificate["field"] == "F2", "field") + check(certificate["equivalence"] == "block-diagonal similarity; labeled vertices", + "equivalence") + check([tuple(x["widths"]) for x in certificate["profiles"]] == list(PROFILES), + "profile domain") + for record in certificate["profiles"]: + verify_profile(record) + + +if __name__ == "__main__": + import json + from pathlib import Path + + verify_certificate(json.loads((Path(__file__).parent / "RESULT.json").read_text())) + print("PASS_BINARY_C5_INDEPENDENT_KERNEL_AND_FULL_GROUP") diff --git a/research/binary-c5-total-seven-orbits/verify.py b/research/binary-c5-total-seven-orbits/verify.py new file mode 100644 index 0000000000..334304144b --- /dev/null +++ b/research/binary-c5-total-seven-orbits/verify.py @@ -0,0 +1,44 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Replay the new finite certificate; produced by Nick Petalas.""" + +import argparse +import hashlib +import json +from pathlib import Path +import platform +import sys +import time + +from census import run_census, require + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--receipt", type=Path) + args = parser.parse_args() + started = time.monotonic() + actual = run_census() + package = Path(__file__).parent + expected = json.loads((package / "RESULT.json").read_text()) + require(canonical(actual) == canonical(expected), "finite classification mismatch") + digest = hashlib.sha256(canonical(actual).encode()).hexdigest() + if args.receipt: + files = ("census.py", "independent.py", "controls.py", "verify.py", "RESULT.json", + "README.md", "TASK.json", "SOURCES.json", "VERIFY.json") + receipt = {"status": "PASS_BINARY_C5_TOTAL_SEVEN_ORBITS", "result_sha256": digest, + "python": sys.version, "platform": platform.platform(), + "elapsed_seconds": time.monotonic() - started, + "files": {name: hashlib.sha256((package / name).read_bytes()).hexdigest() + for name in files}} + args.receipt.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + for result in actual["profiles"]: + print({key: value for key, value in result.items() if key != "orbits"}) + print("PASS_BINARY_C5_TOTAL_SEVEN_ORBITS", digest) + + +if __name__ == "__main__": + main()