From b9c280c49d9c0c15f88c386286e6cd2a892efb67 Mon Sep 17 00:00:00 2001 From: 4RchYMing <275918740+4RchYMing@users.noreply.github.com> Date: Tue, 13 Oct 2026 13:57:43 +0800 Subject: [PATCH 1/2] Speed up exact cyclic routing verification with packed joint states Preserve every original frontier and complete certificate receipt while reducing full-check wall time and Python allocation peaks. Include an independent literal-state oracle, negative controls, pinned original replays, and alternating same-environment benchmarks. Base-Commit: 66849e1475c930fd7732b1a0067ffee7e1e95f60 AI-Assistance: OpenAI Codex provided substantial implementation, mathematical reasoning, experimentation, validation, and documentation assistance. --- certificates/cyclic-topology-audit.json | 2 +- .../EXPLORATION.json | 39 +++ .../INITIAL-RESULT.json | 225 ++++++++++++++++++ research/cyclic-routing-performance/README.md | 143 +++++++++++ .../cyclic-routing-performance/RESULT.json | 224 +++++++++++++++++ .../cyclic-routing-performance/SELECTION.json | 73 ++++++ .../cyclic-routing-performance/SOURCE.json | 23 ++ .../cyclic-routing-performance/VALIDATION.txt | 118 +++++++++ .../cyclic-routing-performance/benchmark.py | 133 +++++++++++ scripts/audit_cyclic_topology.py | 28 ++- tests/test_cyclic_routing_packed.py | 121 ++++++++++ 11 files changed, 1120 insertions(+), 9 deletions(-) create mode 100644 research/cyclic-routing-performance/EXPLORATION.json create mode 100644 research/cyclic-routing-performance/INITIAL-RESULT.json create mode 100644 research/cyclic-routing-performance/README.md create mode 100644 research/cyclic-routing-performance/RESULT.json create mode 100644 research/cyclic-routing-performance/SELECTION.json create mode 100644 research/cyclic-routing-performance/SOURCE.json create mode 100644 research/cyclic-routing-performance/VALIDATION.txt create mode 100644 research/cyclic-routing-performance/benchmark.py create mode 100644 tests/test_cyclic_routing_packed.py diff --git a/certificates/cyclic-topology-audit.json b/certificates/cyclic-topology-audit.json index 3c85c2ce1b..a2733b3c74 100644 --- a/certificates/cyclic-topology-audit.json +++ b/certificates/cyclic-topology-audit.json @@ -2237,7 +2237,7 @@ "full_improved_frame_certificate_supplied": false, "source_sha256": { "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", - "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29", + "scripts/audit_cyclic_topology.py": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7" }, "status": "GENERAL EXACT VERIFIER; ROUTING OBSTRUCTION; NO NEW KAPPA", diff --git a/research/cyclic-routing-performance/EXPLORATION.json b/research/cyclic-routing-performance/EXPLORATION.json new file mode 100644 index 0000000000..42ed470274 --- /dev/null +++ b/research/cyclic-routing-performance/EXPLORATION.json @@ -0,0 +1,39 @@ +{ + "first_packed_full_audit_seconds": 2.6276306999989174, + "profiled_candidates": [ + { + "hypothesis": "Pack the joint scalar/routing state injectively to reduce hashing, sorting and memory costs while preserving all frontier digests", + "object": "audit_cyclic_topology.routing_state_search", + "profiled_complete_audit_seconds": 5.670541600000433, + "selected": true + }, + { + "hypothesis": "Batch exact finite-field scalar updates", + "object": "experiments.prime_core.inspect_prime", + "profiled_small_compiler_control_seconds": 0.2965042000014364, + "reason": "Small control is cheap; larger end-to-end contribution would require a wider scalar replay scope", + "selected": false + }, + { + "hypothesis": "Reuse feature evaluations while preserving every explicit factor and orthogonality row", + "object": "experiments.signed_sparse_core.expand_factor", + "profiled_complete_audit_seconds": 0.5094451000004483, + "reason": "Complete historical audit is already cheap; frame validation, rather than factor expansion, dominates", + "selected": false + } + ], + "scope": "Exploratory timings; not the paired benchmark claim. Each full receipt agreed after restoring the original checker-source hash.", + "unprofiled_full_audit_order": [ + "before", + "after", + "after", + "before" + ], + "unprofiled_full_audit_seconds": [ + 3.5537824999992154, + 2.3603010999995604, + 2.465378899998541, + 3.586035799999081 + ], + "warning": "The initial three-candidate cProfile probe and four unprofiled in-process audit timings do not have identical instrumentation. They are disclosed separately and excluded from RESULT.json medians." +} diff --git a/research/cyclic-routing-performance/INITIAL-RESULT.json b/research/cyclic-routing-performance/INITIAL-RESULT.json new file mode 100644 index 0000000000..d5fa68f8fd --- /dev/null +++ b/research/cyclic-routing-performance/INITIAL-RESULT.json @@ -0,0 +1,225 @@ +{ + "benchmark_sha256": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "git": "git version 2.49.0.windows.1", + "logical_cpus": 16, + "machine": "AMD64", + "measured_utc": "2026-10-13T05:38:05.691497+00:00", + "medians": { + "after": { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.400476799999524, + "process_wall_seconds": 2.6701709999997547 + }, + "before": { + "audit_cpu_seconds": 3.390625, + "audit_wall_seconds": 3.3898141000008764, + "process_wall_seconds": 3.6527166000014404 + } + }, + "pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "SOURCES.json": "e4e785a201a8345e871abf6753ba7a10d57654ac4b62fc007bcdddabe6311441", + "certificates/paired-network.json": "3b28a213059130bf683c3c70c57e083d90d2ffb0a401b8a50332b98b9ebb303f", + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + } + }, + "platform": "Windows-10-10.0.19045-SP0", + "process_wall_speedup": 1.3679710400576501, + "processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel", + "python": "3.12.14 (main, Aug 25 2026, 14:01:42) [MSC v.1944 64 bit (AMD64)]", + "samples": [ + { + "audit_cpu_seconds": 4.125, + "audit_wall_seconds": 4.156492000000071, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 4.514300200000434, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.734375, + "audit_wall_seconds": 2.775571600001058, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 3.11106110000037, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.400476799999524, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 2.66143430000011, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.34375, + "audit_wall_seconds": 3.344761100001051, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.609574399999474, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.5, + "audit_wall_seconds": 3.508494100000462, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.7851694999990286, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.34375, + "audit_wall_seconds": 2.350519199999326, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 2.6183595999991667, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.40625, + "audit_wall_seconds": 2.422878800000035, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 2.6865809000009904, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.4375, + "audit_wall_seconds": 3.436644699999306, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.7164467000002332, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.359375, + "audit_wall_seconds": 3.373357299999043, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.6425360000012006, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.3948206999994, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 2.6701709999997547, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.421875, + "audit_wall_seconds": 2.4221502999989752, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 2.692057599999316, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.375, + "audit_wall_seconds": 3.379624799999874, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 3.644280600001366, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.390625, + "audit_wall_seconds": 3.3898141000008764, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 3.6527166000014404, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.3911442999997234, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 2.6545300999987376, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "scope": "Complete historical certificate only; no selected-frontier or multiplication runtime claim. Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use tracemalloc in separate untimed processes and are not RSS.", + "separate_memory_samples": [ + { + "audit_cpu_seconds": 36.484375, + "audit_wall_seconds": 36.59164670000064, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 131099209, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 50.90625, + "audit_wall_seconds": 50.99678359999962, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 80510849, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "status": "PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS" +} diff --git a/research/cyclic-routing-performance/README.md b/research/cyclic-routing-performance/README.md new file mode 100644 index 0000000000..db72938a93 --- /dev/null +++ b/research/cyclic-routing-performance/README.md @@ -0,0 +1,143 @@ +# Packed states for the historical cyclic routing audit + +This tooling change reduces the cost of `routing_state_search` without changing +its search domain, pruning rules, receipts, or mathematical conclusions. It +preserves all 529,066 nonsaturated four-role states through depth seven, every +frontier SHA-256, saturation count, terminal count, and the complete eight cyclic +seed controls. There is **no new kappa, construction, or negative result**. + +Base commit: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +The original checker was preserved in commit +`d55bcd62ceb8f322bcf311a5a66e94c3ac7724f0` by Douglas R. Colkitt. +`SOURCE.json` pins the original checker/certificate and the unchanged imported +dependencies. Only the historical certificate's checker-source hash changes; +`upstream/` and the selected #626/#543 frontier remain unchanged. + +## Object, method, and exactness argument + +The original search stores `(A, R)`, where `A` consists of the `W` scalar rows +over F2 and `R` is a bit set of routable permutations in the original +lexicographic permutation order. Here `W` is 2, 3, or 4 and the depth cap is at +most seven. Starting with the identity, a gate performs `A[t] ^= A[s]` and +extends the routing set by the same physical transposition as before. + +Let `b = W!`, `q = 2^W`, and let `A_i` be the integer encoding of row `i`. +The new state is the exact Python integer + + P = (sum(A_i * q^(W-1-i), i=0,...,W-1) << b) | R. + +Every `A_i` lies in `[0,q)` and `R` lies in `[0,2^b)`. The fields therefore do +not overlap: this is a bijective encoding of the complete joint state, not a +hash or a scalar-only merge. In particular, different routing sets remain +different states even when their scalar matrices agree. Numeric ordering of +`P` is exactly the old lexicographic ordering of `(tuple(A_i), R)`. + +An XOR update changes only the target's `W`-bit lane. No carries, modular +approximation, or narrowing integer conversion occur. Routing extension and +its per-call cache are unchanged. Consequently, induction on the BFS depth +preserves each frontier, the visited set, saturation counts, and stopping +conditions. Decoding sorted states back into the original representation +preserves the literal bytes sent to the original SHA-256 accumulator. + +The terminal lookup enumerates all permutation matrices. This agrees with the +old one-hot-row predicate on every reachable matrix: distinct-row XOR updates +preserve invertibility, so a reachable matrix with one-hot rows cannot have a +repeated row. The optimization relies on this reachable-state invariant; it +does not offer a classifier for arbitrary singular matrices. + +## Reproduce + +Use standard-library Python 3.11+ and Git in a full repository clone containing +the base commit. No external Python packages are required. + +```sh +python3 -B research/cyclic-routing-performance/benchmark.py --pairs 7 --out routing-benchmark.json +python3 -B -m unittest discover -s tests -p test_cyclic_routing_packed.py -v +python3 -B -m unittest discover -s tests -p test_finite_bit_contract.py -v +``` + +Use a fresh benchmark output path. Expected: the benchmark ends with +`PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS`; the two test commands pass five and +nine tests respectively. The benchmark loads the original implementation from +the exact Git object, admits pinned dependency bytes, and runs the complete +certificate in both modes. Every field must match the frozen original after +restoring only the changed checker-source binding. It records all samples and +rejects source drift, changed receipts, and reused output files. + +To regenerate the historical certificate, run +`python3 scripts/audit_cyclic_topology.py`. Its numerical and frontier payloads +remain unchanged. The new source binding is committed with this change. + +## Measurements and validation + +`RESULT.json` records seven sequential, alternating fresh-process pairs on +Windows 10 / CPython 3.12.14, x86-64, with the interpreter, Git version, +processor identifier, source hashes, and all raw samples. OS caches were not +flushed. Both modes perform the same source-admission and receipt checks. + +| Measurement | Original | Packed | +|---|---:|---:| +| Complete-process wall median | 3.788324 s | 2.680431 s | +| Certificate execution wall median | 3.528838 s | 2.417635 s | +| Certificate execution CPU median | 3.515625 s | 2.421875 s | +| Python allocation peak, separate traced run | 131,099,209 bytes | 80,510,849 bytes | + +The complete-process median is 1.413 times faster (29.24% less elapsed time). +The separately measured Python allocation peak falls by 38.59%. It is **not +process RSS**; `tracemalloc` is disabled in all timing samples. One memory run +per mode measures the complete certificate, not just a synthetic key array. +No timing threshold is imposed, and other environments may differ. + +The new independent oracle uses dense F2 rows and literal sets of permutation +tuples, rather than either implementation's packed state or routing masks. +It compares every receipt field at each cap 0–7 for two/three roles and 0–4 for +four roles. Full depth-seven receipts are also compared with the original +committed certificate. A deliberately incorrect scalar-only merge still finds +no survivor, but loses states and changes frontier digests; the negative +control detects this loss. Other tests distinguish a depth cutoff from closure +and retain width/depth input rejections. The original finite-contract tests +independently enumerate short raw XOR words and exercise malformed circuits, +terminal obligations, routing failures, and budget exhaustion. + +Preliminary measurements are retained in `EXPLORATION.json`; profiled timings +are not used to claim the speedup. `INITIAL-RESULT.json` retains the first +seven-pair run (3.652717 s to 2.670171 s, 1.368 times faster). The final run +followed a source-admission review that added an +explicit upstream-manifest pin and removed two unused input pins; the numerical +kernel did not change. `VALIDATION.txt` records executed checks, including a +minimal offline replay in a path containing spaces and source-drift/output +reuse rejection controls. + +## Scope, prior work, and attribution + +The [original routing note](../../docs/research/cyclic-topology-audit.md) supplies +the finite-state reduction and the edge-disjoint-routing rank argument. The +two/three-role frontier closes; the four-role frontier does not. The latter +still excludes only words through seven primitive gates. This work neither +extends that domain nor formalizes those arguments in Lean. The inherited +all-size, compiler, physical realization, precision/tape, and analytic transfer +obligations are unaffected. + +Assignment seed **87** came from the Windows operating system cryptographic +random source via `RandomNumberGenerator.GetInt32(0,100)`. `SELECTION.json` +records the three candidates, profiling, overlap check, and local scope claim. +No pinned sprint coordination issue was available. + +Douglas R. Colkitt authored the original checker, routing obstruction, and +historical certificate. Pending [PR154](https://github.com/CrocSwap/integer-mult-bounds/pull/154) +by eumemic reports other verifier hotspots; pending +[PR756](https://github.com/CrocSwap/integer-mult-bounds/pull/756) by Victor Li +optimizes the distinct balanced-Fano meet-in-the-middle search. Neither is a +code dependency or an independently reviewed result here. The frozen upstream +and all predecessor notices retain their attribution. + +Contributor: **4RchYMing**, authenticated GitHub account ID 275918740; commit +email `275918740+4RchYMing@users.noreply.github.com`, as specified by the user. +Prepared with **substantial OpenAI Codex assistance**, including implementation, +proof reasoning, experiments, and tests. There is no claim of independent +human peer review. Apache-2.0, as in the parent project. + +Full `make verify`, the selected supplier cold replay, Lean, and remote Linux +CI have not been run for this isolated historical-verifier change. The local +environment lacks `make` and a C++ compiler. Their status must not be inferred +from the finite checks or benchmark receipts. diff --git a/research/cyclic-routing-performance/RESULT.json b/research/cyclic-routing-performance/RESULT.json new file mode 100644 index 0000000000..d8712b39e7 --- /dev/null +++ b/research/cyclic-routing-performance/RESULT.json @@ -0,0 +1,224 @@ +{ + "benchmark_sha256": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "git": "git version 2.49.0.windows.1", + "logical_cpus": 16, + "machine": "AMD64", + "measured_utc": "2026-10-13T05:52:04.120503+00:00", + "medians": { + "after": { + "audit_cpu_seconds": 2.421875, + "audit_wall_seconds": 2.417635400001018, + "process_wall_seconds": 2.680431299999327 + }, + "before": { + "audit_cpu_seconds": 3.515625, + "audit_wall_seconds": 3.5288375000000087, + "process_wall_seconds": 3.7883240999999543 + } + }, + "pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "platform": "Windows-10-10.0.19045-SP0", + "process_wall_speedup": 1.413326318044751, + "processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel", + "python": "3.12.14 (main, Aug 25 2026, 14:01:42) [MSC v.1944 64 bit (AMD64)]", + "samples": [ + { + "audit_cpu_seconds": 3.40625, + "audit_wall_seconds": 3.4254423000002134, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 3.7141272999997454, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.421875, + "audit_wall_seconds": 2.417635400001018, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 2.680431299999327, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.453125, + "audit_wall_seconds": 2.4569194999985484, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 2.72749339999973, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.515625, + "audit_wall_seconds": 3.5288375000000087, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.7883240999999543, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.53125, + "audit_wall_seconds": 3.549399199999243, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.816472900000008, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.399705100000574, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 2.662013500001194, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.375, + "audit_wall_seconds": 2.365412999999535, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 2.629450000000361, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.390625, + "audit_wall_seconds": 3.4024438000014925, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.6713786000000255, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.390625, + "audit_wall_seconds": 3.3816540999996505, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.6604882999999973, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.453125, + "audit_wall_seconds": 2.4593995999985054, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 2.722653299999365, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.6875, + "audit_wall_seconds": 2.6879036000009364, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 3.0016517999993084, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 4.34375, + "audit_wall_seconds": 4.343263900000238, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 4.655810099999144, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.640625, + "audit_wall_seconds": 3.6364293000006, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 3.936116500000935, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.40625, + "audit_wall_seconds": 2.4020677999997133, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 2.672384699999384, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "scope": "Complete historical certificate only; no selected-frontier or multiplication runtime claim. Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use tracemalloc in separate untimed processes and are not RSS.", + "separate_memory_samples": [ + { + "audit_cpu_seconds": 40.0, + "audit_wall_seconds": 41.09008370000083, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 131099209, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 51.9375, + "audit_wall_seconds": 51.94774730000063, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 80510849, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "status": "PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS" +} diff --git a/research/cyclic-routing-performance/SELECTION.json b/research/cyclic-routing-performance/SELECTION.json new file mode 100644 index 0000000000..a0300152e4 --- /dev/null +++ b/research/cyclic-routing-performance/SELECTION.json @@ -0,0 +1,73 @@ +{ + "attribution": "4RchYMing, with substantial OpenAI Codex assistance. Original routing checker and theorem: Douglas R. Colkitt.", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "branch": "research/seed87-verification-engineering", + "candidates": [ + { + "hypothesis": "Pack the joint scalar/routing state injectively to reduce hashing, sorting and memory costs while preserving all frontier digests", + "object": "audit_cyclic_topology.routing_state_search", + "profiled_complete_audit_seconds": 5.670541600000433, + "selected": true + }, + { + "hypothesis": "Batch exact finite-field scalar updates", + "object": "experiments.prime_core.inspect_prime", + "profiled_small_compiler_control_seconds": 0.2965042000014364, + "reason": "Small control is cheap; larger end-to-end contribution would require a wider scalar replay scope", + "selected": false + }, + { + "hypothesis": "Reuse feature evaluations while preserving every explicit factor and orthogonality row", + "object": "experiments.signed_sparse_core.expand_factor", + "profiled_complete_audit_seconds": 0.5094451000004483, + "reason": "Complete historical audit is already cheap; frame validation, rather than factor expansion, dominates", + "selected": false + } + ], + "claim_recorded_utc": "2026-10-13T05:29:23.634499+00:00", + "claim_recorded_utc_source": "Local claim file modification time, recorded before the implementation edit.", + "completion": { + "completed_utc": "2026-10-13T05:56:02.889541+00:00", + "proof_scope": "Encoding and reachable-state equivalence argument; independent finite controls, not a formal multiplication theorem", + "status": "Verified tooling contribution; ready for commit and one upstream PR" + }, + "coordination": "No pinned sprint coordination issue visible; the only open non-PR issue was #650 (Discussions). Local claim; GitHub CLI currently unauthenticated.", + "delivery_identity": { + "fork": "https://github.com/4RchYMing/integer-mult-bounds", + "fork_push_permission": true, + "git_email": "275918740+4RchYMing@users.noreply.github.com", + "git_name": "4RchYMing", + "github_id": 275918740, + "github_login": "4RchYMing", + "upstream_push_permission": false, + "verified_by": [ + "gh auth status", + "gh api user", + "git config --local --get user.name", + "git config --local --get user.email" + ] + }, + "expected_deliverable": "One focused tooling change with exact equivalence argument, meaningful negative controls, alternating same-environment full-check benchmarks and a reproducible handoff.", + "gist_content_sha256": "7d3f15eb6f7801ebb7c1606d7869a63f6ce5b25be1d048c6a8a9321ef1516005", + "gist_revision": "4180bf0d4045ffdcd12d75bb1fec91c234420162", + "gist_url": "https://gist.github.com/Mister-Meeseeks/9f768c8b1a3e7d2e70b8e5c0bc18ab7e", + "latest_overlap_check": { + "checked_utc": "2026-10-13T05:49:54.388224+00:00", + "coordination_source": "Authenticated repository.pinnedIssues GraphQL query returned zero nodes", + "final_incremental_latest_pr": 799, + "final_upstream_main": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "latest_pr": 795, + "open_prs": 614, + "pinned_coordination_issues": [], + "scope_match": "No cyclic-topology/routing_state_search/packed-routing work found; #197 mentions unrelated joint-frame/routing work." + }, + "method": "Use an order-preserving injective integer encoding of the full scalar matrix AND routing set; compare full receipts against the base implementation and validate transitions against independent literal routing enumeration.", + "overlap_snapshot": "open-prs.json: 588 open PRs; checked titles and bodies for cyclic topology, routing_state_search and signed-sparse overlap. PR154 gives other profiling leads; PR756 covers a distinct balanced-Fano search. No pending code imported.", + "planned_finish": "2026-10-13T14:41:00+08:00", + "scope": "Only the historical two-port XOR joint-state routing screen, W in {2,3,4}, depth at most 7. No larger search, new obstruction, new kappa or selected-frontier change.", + "seed": 87, + "seed_generated_utc": "2026-10-13T05:22:23.2012480Z", + "seed_source": "System.Security.Cryptography.RandomNumberGenerator.GetInt32(0,100)", + "track": "verification engineering", + "verification_delivery_begins_no_later_than": "2026-10-13T14:21:00+08:00" +} diff --git a/research/cyclic-routing-performance/SOURCE.json b/research/cyclic-routing-performance/SOURCE.json new file mode 100644 index 0000000000..253bcc01f1 --- /dev/null +++ b/research/cyclic-routing-performance/SOURCE.json @@ -0,0 +1,23 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } +} diff --git a/research/cyclic-routing-performance/VALIDATION.txt b/research/cyclic-routing-performance/VALIDATION.txt new file mode 100644 index 0000000000..709cce64be --- /dev/null +++ b/research/cyclic-routing-performance/VALIDATION.txt @@ -0,0 +1,118 @@ +Validation UTC: 2026-10-13T05:42:26.751718+00:00 +Python: 3.12.14 (main, Aug 25 2026, 14:01:42) [MSC v.1944 64 bit (AMD64)] + +COMMAND: C:\Users\Ming\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe -X utf8 -B -m unittest discover -s tests -p test_cyclic_routing_packed.py -v +test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok +test_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok +test_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok +test_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok +test_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok + +---------------------------------------------------------------------- +Ran 5 tests in 3.024s + +OK +EXIT CODE: 0 + +COMMAND: C:\Users\Ming\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe -X utf8 -B -m unittest discover -s tests -p test_finite_bit_contract.py -v +test_complete_role_permutation_and_orientation (test_finite_bit_contract.FiniteBitContract.test_complete_role_permutation_and_orientation) ... ok +test_exact_rational_schema_and_all_terminal_dimensions (test_finite_bit_contract.FiniteBitContract.test_exact_rational_schema_and_all_terminal_dimensions) ... ok +test_free_nonprojector_frames_and_gauge_invariance (test_finite_bit_contract.FiniteBitContract.test_free_nonprojector_frames_and_gauge_invariance) ... ok +test_nonpermutation_or_invalid_gate_cannot_be_scored (test_finite_bit_contract.FiniteBitContract.test_nonpermutation_or_invalid_gate_cannot_be_scored) ... ok +test_routing_certificates_cover_every_physical_edge (test_finite_bit_contract.FiniteBitContract.test_routing_certificates_cover_every_physical_edge) ... ok +test_scratch_roles_and_untouched_wire_edges_are_not_omitted (test_finite_bit_contract.FiniteBitContract.test_scratch_roles_and_untouched_wire_edges_are_not_omitted) ... ok +test_short_word_search_against_independent_enumeration (test_finite_bit_contract.FiniteBitContract.test_short_word_search_against_independent_enumeration) ... ok +test_small_role_closure_and_four_role_scope (test_finite_bit_contract.FiniteBitContract.test_small_role_closure_and_four_role_scope) ... ok +test_tampered_routes_and_exhausted_search_budget_rejected (test_finite_bit_contract.FiniteBitContract.test_tampered_routes_and_exhausted_search_budget_rejected) ... ok + +---------------------------------------------------------------------- +Ran 9 tests in 0.037s + +OK +EXIT CODE: 0 + +COMMAND: C:\Users\Ming\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe -X utf8 -O -B -m unittest discover -s tests -p test_cyclic_routing_packed.py -v +test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok +test_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok +test_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok +test_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok +test_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok + +---------------------------------------------------------------------- +Ran 5 tests in 2.892s + +OK +EXIT CODE: 0 + +COMMAND: C:\Users\Ming\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe -X utf8 -S -B -m unittest discover -s tests -p test_cyclic_routing_packed.py -v +test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok +test_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok +test_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok +test_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok +test_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok + +---------------------------------------------------------------------- +Ran 5 tests in 2.688s + +OK +EXIT CODE: 0 + +COMMAND: C:\Users\Ming\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe -X utf8 -B scripts/verify_selected_result.py +PASS selected record, exact kappa, original source inventory and proof supplement: 51110230636731/31250000000000000 +EXIT CODE: 0 + +COMMAND: git diff --check +EXIT CODE: 0 + +PASS entire historical certificate equals base after restoring ONLY the changed checker-source hash. +PASS upstream/, selected record, and selected K492 evidence unchanged. + +ISOLATED REPLAY in path with spaces, before +{"mode": "before", "audit_wall_seconds": 3.6454823999993096, "audit_cpu_seconds": 3.453125, "python_allocation_peak_bytes": null, "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8", "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013"} +EXIT CODE: 0 + +ISOLATED REPLAY in path with spaces, after +{"mode": "after", "audit_wall_seconds": 2.455098200000066, "audit_cpu_seconds": 2.453125, "python_allocation_peak_bytes": null, "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8", "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013"} +EXIT CODE: 0 + +PASS reused output rejected +usage: benchmark.py [-h] [--pairs PAIRS] [--out OUT] +benchmark.py: error: Use positive --pairs and a fresh --out file + +PASS zero pairs rejected +usage: benchmark.py [-h] [--pairs PAIRS] [--out OUT] +benchmark.py: error: Use positive --pairs and a fresh --out file + +PASS changed dependency rejected before execution +Traceback (most recent call last): + File "E:\hunzili\integer-mult-bounds-session\isolated replay with spaces\research\cyclic-routing-performance\benchmark.py", line 133, in + main() + File "E:\hunzili\integer-mult-bounds-session\isolated replay with spaces\research\cyclic-routing-performance\benchmark.py", line 83, in main + child(args.child, args.memory) + File "E:\hunzili\integer-mult-bounds-session\isolated replay with spaces\research\cyclic-routing-performance\benchmark.py", line 44, in child + raise ValueError('Changed dependency: ' + name) +ValueError: Changed dependency: scripts/finite_bit_contract.py + +FINAL BENCHMARK with corrected source admission (SOURCE.json): +before 1 3.714127s +after 1 2.680431s +after 2 2.727493s +before 2 3.788324s +before 3 3.816473s +after 3 2.662014s +after 4 2.629450s +before 4 3.671379s +before 5 3.660488s +after 5 2.722653s +after 6 3.001652s +before 6 4.655810s +before 7 3.936117s +after 7 2.672385s +before Python allocation peak 131099209 +after Python allocation peak 80510849 +PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS + +Manual dependency review: preserved-research-manifest.json records ORIGINAL historical hashes; the PR186 SOURCE.json binds its own frozen package copy. Neither binds the changed live script. Both remain unchanged. +Final upstream/main: 66849e1475c930fd7732b1a0067ffee7e1e95f60 +Git author: 4RchYMing <275918740+4RchYMing@users.noreply.github.com> 1791870962 +0800 +Git committer: 4RchYMing <275918740+4RchYMing@users.noreply.github.com> 1791870962 +0800 diff --git a/research/cyclic-routing-performance/benchmark.py b/research/cyclic-routing-performance/benchmark.py new file mode 100644 index 0000000000..549f619d75 --- /dev/null +++ b/research/cyclic-routing-performance/benchmark.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Compare complete routing receipts and fresh-process timings at a pinned base. + +Standard-library Python 3.11+ and Git; run from any directory in a full clone. +Python allocation peaks are measured separately, never in the timed samples. +""" +import argparse +from datetime import datetime, timezone +from hashlib import sha256 +import json +import os +from pathlib import Path +import platform +import statistics +import subprocess +import sys +import time +import tracemalloc +import types + +ROOT = Path(__file__).resolve().parents[2] +HERE = Path(__file__).resolve().parent +SCRIPT = 'scripts/audit_cyclic_topology.py' +CERTIFICATE = 'certificates/cyclic-topology-audit.json' + + +def canonical(value): + return (json.dumps(value, indent=2, sort_keys=True) + '\n').encode() + + +def git_file(base, name): + return subprocess.check_output(['git', 'show', base + ':' + name], cwd=ROOT) + + +def child(mode, memory): + pins = json.loads((HERE / 'SOURCE.json').read_text(encoding='utf-8')) + original = git_file(pins['base_commit'], SCRIPT) + frozen = git_file(pins['base_commit'], CERTIFICATE) + for name, content in ((SCRIPT, original), (CERTIFICATE, frozen)): + if sha256(content).hexdigest() != pins['base_sha256'][name]: + raise ValueError('Changed reference: ' + name) + for name, expected in pins['dependencies_sha256'].items(): + if sha256((ROOT / name).read_bytes()).hexdigest() != expected: + raise ValueError('Changed dependency: ' + name) + current = (ROOT / SCRIPT).read_bytes() + module = types.ModuleType('routing_benchmark_subject') + module.__file__ = str(ROOT / SCRIPT) + sys.path.insert(0, str(ROOT / 'scripts')) + exec(compile(original if mode == 'before' else current, module.__file__, 'exec'), + module.__dict__) + if memory: + tracemalloc.start() + wall, cpu = time.perf_counter(), time.process_time() + receipt = module.certificate() + wall, cpu = time.perf_counter() - wall, time.process_time() - cpu + peak = tracemalloc.get_traced_memory()[1] if memory else None + if memory: + tracemalloc.stop() + normalized = json.loads(json.dumps(receipt)) + normalized['source_sha256'][SCRIPT] = pins['base_sha256'][SCRIPT] + if normalized != json.loads(frozen): + raise ValueError('Complete historical receipt differs (beyond the source binding)') + imports = {Path(m.__file__).resolve() for m in list(sys.modules.values()) + if getattr(m, '__file__', None) and + Path(m.__file__).resolve().is_relative_to(ROOT / 'scripts')} + if not {p.relative_to(ROOT).as_posix() for p in imports} <= set(pins['dependencies_sha256']): + raise ValueError('An imported dependency is missing from SOURCE.json') + print(json.dumps(dict(mode=mode, audit_wall_seconds=wall, audit_cpu_seconds=cpu, + python_allocation_peak_bytes=peak, + receipt_sha256=sha256(canonical(receipt)).hexdigest(), + normalized_receipt_sha256=sha256(canonical(normalized)).hexdigest(), + current_source_sha256=sha256(current).hexdigest()))) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--pairs', type=int, default=7) + parser.add_argument('--out', type=Path) + parser.add_argument('--child', choices=('before', 'after'), help=argparse.SUPPRESS) + parser.add_argument('--memory', action='store_true', help=argparse.SUPPRESS) + args = parser.parse_args() + if args.child: + child(args.child, args.memory) + return + if args.pairs < 1 or args.out is None or args.out.exists(): + parser.error('Use positive --pairs and a fresh --out file') + env = dict(os.environ, PYTHONHASHSEED='0', PYTHONDONTWRITEBYTECODE='1') + env.pop('PYTHONOPTIMIZE', None) + samples = [] + for pair in range(args.pairs): + for mode in (('before', 'after') if pair % 2 == 0 else ('after', 'before')): + start = time.perf_counter() + process = subprocess.run([sys.executable, '-I', '-B', str(Path(__file__).resolve()), + '--child', mode], cwd=ROOT, env=env, + capture_output=True, text=True, check=True) + sample = json.loads(process.stdout) + sample.update(pair=pair, process_wall_seconds=time.perf_counter() - start) + samples.append(sample) + print(mode, pair + 1, f"{sample['process_wall_seconds']:.6f}s", flush=True) + memory = [] + for mode in ('before', 'after'): + process = subprocess.run([sys.executable, '-I', '-B', str(Path(__file__).resolve()), + '--child', mode, '--memory'], cwd=ROOT, env=env, + capture_output=True, text=True, check=True) + memory.append(json.loads(process.stdout)) + print(mode, 'Python allocation peak', memory[-1]['python_allocation_peak_bytes'], flush=True) + all_samples = samples + memory + for key in ('receipt_sha256', 'normalized_receipt_sha256', 'current_source_sha256'): + if len({sample[key] for sample in all_samples}) != 1: + raise ValueError('Inconsistent full receipts or source: ' + key) + summary = {mode: {metric: statistics.median(s[metric] for s in samples if s['mode'] == mode) + for metric in ('process_wall_seconds', 'audit_wall_seconds', 'audit_cpu_seconds')} + for mode in ('before', 'after')} + result = dict(status='PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS', + measured_utc=datetime.now(timezone.utc).isoformat(), + python=sys.version, platform=platform.platform(), machine=platform.machine(), + processor=platform.processor(), logical_cpus=os.cpu_count(), + git=subprocess.check_output(['git', '--version'], text=True).strip(), + pins=json.loads((HERE / 'SOURCE.json').read_text(encoding='utf-8')), + benchmark_sha256=sha256(Path(__file__).read_bytes()).hexdigest(), + samples=samples, separate_memory_samples=memory, medians=summary, + process_wall_speedup=summary['before']['process_wall_seconds'] / + summary['after']['process_wall_seconds'], + scope='Complete historical certificate only; no selected-frontier or multiplication runtime claim. ' + 'Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use ' + 'tracemalloc in separate untimed processes and are not RSS.') + with args.out.open('x', encoding='utf-8', newline='\n') as output: + output.write(canonical(result).decode()) + print(result['status']) + + +if __name__ == '__main__': + main() diff --git a/scripts/audit_cyclic_topology.py b/scripts/audit_cyclic_topology.py index a6420a4ccf..78738042eb 100644 --- a/scripts/audit_cyclic_topology.py +++ b/scripts/audit_cyclic_topology.py @@ -52,17 +52,28 @@ def extend(R,pair): bits -= bit return result - initial = (tuple(1 << i for i in range(W)),1) + # High-to-low row lanes preserve tuple order; the low bits retain all of R. + shifts = [W*(W-1-i) for i in range(W)] + row_mask = (1 << W)-1 + routing_bits = len(perms) + permutation_index = { + sum((1 << p[i]) << shifts[i] for i in range(W)):j + for j,p in enumerate(perms) + } + identity = sum((1 << i) << shifts[i] for i in range(W)) + initial = (identity << routing_bits) | 1 seen = {initial}; frontier = {initial}; layers = []; saturated = 0 all_length = False; survivors = [] for depth in range(max_depth+1): terminals = 0; digest = sha256() - for M,R in sorted(frontier): + for packed in sorted(frontier): + scalar, R = packed >> routing_bits, packed & full + M = tuple((scalar >> shift) & row_mask for shift in shifts) digest.update((repr((M,R))+'\n').encode()) - if all(x and x & (x-1) == 0 for x in M): + permutation = permutation_index.get(scalar) + if permutation is not None: terminals += 1 - p = tuple(x.bit_length()-1 for x in M) - if not (R >> index[p]) & 1: + if not (R >> permutation) & 1: survivors.append(dict(depth=depth,scalar_rows=list(M),routing_set=R)) layers.append(dict(depth=depth,new_states=len(frontier), permutation_states=terminals,frontier_sha256=digest.hexdigest())) @@ -70,15 +81,16 @@ def extend(R,pair): all_length = not frontier break nxt = set() - for M,R in frontier: + for packed in frontier: + scalar, R = packed >> routing_bits, packed & full for pair,(a,b) in enumerate(pairs): S = extend(R,pair) if S == full: saturated += 2 continue for t,s in ((a,b),(b,a)): - A = list(M); A[t] ^= A[s] - state = (tuple(A),S) + A = scalar ^ (((scalar >> shifts[s]) & row_mask) << shifts[t]) + state = (A << routing_bits) | S if state not in seen: nxt.add(state) seen.update(nxt); frontier = nxt return dict(W=W,depth_cap=max_depth,layers=layers,distinct_joint_states=len(seen), diff --git a/tests/test_cyclic_routing_packed.py b/tests/test_cyclic_routing_packed.py new file mode 100644 index 0000000000..a1b8c75bdf --- /dev/null +++ b/tests/test_cyclic_routing_packed.py @@ -0,0 +1,121 @@ +"""Independent literal-state oracle for the historical routing screen.""" +from hashlib import sha256 +from itertools import permutations +from pathlib import Path +import json +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'scripts')) +from audit_cyclic_topology import routing_state_search + + +def literal_search(width, depth_cap, scalar_only=False): + """Dense F2 rows and literal sets of permutations, with no packed states. + + scalar_only deliberately implements an invalid state merge for a control. + """ + perms = list(permutations(range(width))) + identity = tuple(tuple(int(i == j) for j in range(width)) + for i in range(width)) + initial = identity, frozenset([tuple(range(width))]) + seen = {initial} + frontier = {initial} + layers = [] + saturated = 0 + survivors = [] + for depth in range(depth_cap + 1): + serialized = [] + terminals = 0 + for matrix, routes in frontier: + rows = tuple(sum(x << j for j, x in enumerate(row)) for row in matrix) + route_bits = sum(1 << j for j, p in enumerate(perms) if p in routes) + serialized.append((rows, route_bits)) + if all(sum(row) == 1 for row in matrix): + terminals += 1 + scalar_route = tuple(row.index(1) for row in matrix) + if scalar_route not in routes: + survivors.append(dict(depth=depth, scalar_rows=list(rows), + routing_set=route_bits)) + digest = sha256(''.join(repr(s) + '\n' for s in sorted(serialized)).encode()) + layers.append(dict(depth=depth, new_states=len(frontier), + permutation_states=terminals, + frontier_sha256=digest.hexdigest())) + if survivors or not frontier or depth == depth_cap: + break + following = set() + scalar_seen = {matrix for matrix, _ in seen} + for matrix, routes in sorted(frontier, key=repr): + for target in range(width): + for source in range(width): + if target == source: + continue + extended = set(routes) + for p in routes: + q = list(p) + q[target], q[source] = q[source], q[target] + extended.add(tuple(q)) + if len(extended) == len(perms): + saturated += 1 + continue + changed = list(matrix) + changed[target] = tuple((x + y) % 2 for x, y in + zip(matrix[target], matrix[source])) + state = tuple(changed), frozenset(extended) + if state not in seen: + if not scalar_only or state[0] not in scalar_seen: + following.add(state) + scalar_seen.add(state[0]) + seen.update(following) + frontier = following + return dict(layers=layers, distinct_joint_states=len(seen), + saturated_transitions_discarded=saturated, + frontier_closed=not frontier, + all_lengths_excluded=not frontier and not survivors, + all_words_through_depth_excluded=not survivors, + survivors=sorted(survivors, key=lambda s: (s['depth'], s['scalar_rows'], s['routing_set']))) + + +class CyclicRoutingPackedTest(unittest.TestCase): + def test_complete_frozen_frontiers_and_receipts(self): + frozen = json.loads((ROOT / 'certificates/cyclic-topology-audit.json').read_text()) + for expected in frozen['word_searches']: + with self.subTest(width=expected['W']): + self.assertEqual(routing_state_search(expected['W'], 7), expected) + + def test_dense_scalar_and_literal_routing_oracle(self): + for width, cap in [(2, 7), (3, 7), (4, 4)]: + for depth in range(cap + 1): + with self.subTest(width=width, depth=depth): + expected = literal_search(width, depth) + actual = routing_state_search(width, depth) + self.assertEqual({key: actual[key] for key in expected}, expected) + + def test_scalar_only_merge_loses_coverage_without_finding_a_survivor(self): + correct = routing_state_search(3, 4) + broken = literal_search(3, 4, scalar_only=True) + self.assertEqual(correct['survivors'], broken['survivors']) + self.assertTrue(broken['all_words_through_depth_excluded']) + self.assertLess(broken['distinct_joint_states'], correct['distinct_joint_states']) + self.assertNotEqual(broken['layers'], correct['layers']) + + def test_depth_cutoff_is_not_closure(self): + before_closure = routing_state_search(3, 6) + closed = routing_state_search(3, 7) + self.assertTrue(before_closure['all_words_through_depth_excluded']) + self.assertFalse(before_closure['all_lengths_excluded']) + self.assertTrue(closed['all_lengths_excluded']) + self.assertEqual(before_closure['distinct_joint_states'], closed['distinct_joint_states']) + + def test_invalid_widths_and_depths_still_raise(self): + for width in (0, 1, 5): + with self.subTest(width=width), self.assertRaises(ValueError): + routing_state_search(width, 3) + for depth in (-1, 8, 1.5, True): + with self.subTest(depth=depth), self.assertRaises(ValueError): + routing_state_search(3, depth) + + +if __name__ == '__main__': + unittest.main() From 9ce9273e6b2b6f66b9aabd2fe6d366b6b3988a97 Mon Sep 17 00:00:00 2001 From: 4RchYMing <275918740+4RchYMing@users.noreply.github.com> Date: Tue, 13 Oct 2026 14:40:58 +0800 Subject: [PATCH 2/2] test: cover the full cyclic routing domain with an independent oracle Check every depth cap through seven for all supported widths. Preserve Python 3.11/3.13/3.14 tests, paired benchmarks and current-upstream dependency comparisons without changing the verifier or its certificate. AI assistance: substantial OpenAI Codex assistance with verification, experiments, documentation and delivery. --- research/cyclic-routing-performance/README.md | 53 ++- .../RESULT-python311.json | 224 ++++++++++ .../RESULT-python313.json | 224 ++++++++++ .../RESULT-python314.json | 224 ++++++++++ .../cyclic-routing-performance/SELECTION.json | 26 +- .../VALIDATION-MATRIX.json | 390 ++++++++++++++++++ tests/test_cyclic_routing_packed.py | 2 +- 7 files changed, 1134 insertions(+), 9 deletions(-) create mode 100644 research/cyclic-routing-performance/RESULT-python311.json create mode 100644 research/cyclic-routing-performance/RESULT-python313.json create mode 100644 research/cyclic-routing-performance/RESULT-python314.json create mode 100644 research/cyclic-routing-performance/VALIDATION-MATRIX.json diff --git a/research/cyclic-routing-performance/README.md b/research/cyclic-routing-performance/README.md index db72938a93..adf095bd5a 100644 --- a/research/cyclic-routing-performance/README.md +++ b/research/cyclic-routing-performance/README.md @@ -11,7 +11,8 @@ The original checker was preserved in commit `d55bcd62ceb8f322bcf311a5a66e94c3ac7724f0` by Douglas R. Colkitt. `SOURCE.json` pins the original checker/certificate and the unchanged imported dependencies. Only the historical certificate's checker-source hash changes; -`upstream/` and the selected #626/#543 frontier remain unchanged. +`upstream/` and selected-frontier records remain unchanged. The selected +frontier at this original base was #626/#543. ## Object, method, and exactness argument @@ -88,16 +89,44 @@ process RSS**; `tracemalloc` is disabled in all timing samples. One memory run per mode measures the complete certificate, not just a synthetic key array. No timing threshold is imposed, and other environments may differ. +The additional same-host Windows matrix targets the Python versions used by +upstream CI. Each row has its own seven alternating before/after process pairs +and separately traced memory runs; it is not a comparison between versions. + +| CPython | Original process median | Packed process median | Speedup | Allocation peak reduction | +|---|---:|---:|---:|---:| +| 3.11.16 | 3.436026 s | 2.553110 s | 1.346x | 38.59% | +| 3.13.15 | 3.628811 s | 2.902232 s | 1.250x | 38.61% | +| 3.14.7 | 3.842965 s | 3.198651 s | 1.201x | 42.42% | + +`RESULT-python311.json`, `RESULT-python313.json`, and `RESULT-python314.json` +retain every sample. The Python 3.14 timings vary more; none were discarded. +Together with the two original 3.12 series, all 80 complete certificate receipts +agree. The measured benefit depends on the interpreter and environment; the +original 1.413x result is not a universal speedup guarantee. + +`VALIDATION-MATRIX.json` retains source hashes and complete command output for +all 14 tests under 3.11.16, 3.13.15 and 3.14.7, plus all 14 under 3.14.7 `-O`. +These runs use the full depth-seven independent oracle. Reproduce with the two +test commands above under each interpreter, adding `-O` before `-m` for the +optimized-mode check; run the benchmark under each interpreter with a distinct +output filename. The matrix uses the standard library only, and does not alter +project dependencies or CI settings. + The new independent oracle uses dense F2 rows and literal sets of permutation tuples, rather than either implementation's packed state or routing masks. -It compares every receipt field at each cap 0–7 for two/three roles and 0–4 for -four roles. Full depth-seven receipts are also compared with the original -committed certificate. A deliberately incorrect scalar-only merge still finds -no survivor, but loses states and changes frontier digests; the negative +It compares every receipt field at every cap 0–7 for all three widths, including +an independent replay of all 529,066 four-role states. Full depth-seven receipts +are also compared with the original committed certificate. A deliberately +incorrect scalar-only merge still finds no survivor, but loses states and +changes frontier digests; the negative control detects this loss. Other tests distinguish a depth cutoff from closure and retain width/depth input rejections. The original finite-contract tests independently enumerate short raw XOR words and exercise malformed circuits, terminal obligations, routing failures, and budget exhaustion. +The oracle independently implements the state representation and transitions; +it shares the documented joint-state reduction and saturation rule, and does +not independently prove those reductions or the routing theorem. Preliminary measurements are retained in `EXPLORATION.json`; profiled timings are not used to claim the speedup. `INITIAL-RESULT.json` retains the first @@ -110,6 +139,15 @@ reuse rejection controls. ## Scope, prior work, and attribution +Upstream advanced to `7ee02b7c96d85f22b38d28bd7ed49bb8c1aeb261` during the +follow-up and selected #741. The compatibility record in +`VALIDATION-MATRIX.json` compares actual file bytes at that immutable main +commit: all 14 pinned dependencies, the original checker/certificate, the +finite-contract tests, the isolated test runner and general CI workflow are +unchanged (19 files). This preserves the original experiment's input basis; +it is not a replay or endorsement of the new selected construction. No frontier +record is edited or rebased into this contribution. + The [original routing note](../../docs/research/cyclic-topology-audit.md) supplies the finite-state reduction and the edge-disjoint-routing rank argument. The two/three-role frontier closes; the four-role frontier does not. The latter @@ -139,5 +177,6 @@ human peer review. Apache-2.0, as in the parent project. Full `make verify`, the selected supplier cold replay, Lean, and remote Linux CI have not been run for this isolated historical-verifier change. The local -environment lacks `make` and a C++ compiler. Their status must not be inferred -from the finite checks or benchmark receipts. +environment lacks `make` and a C++ compiler. At the follow-up check, upstream +Actions returned `action_required`, awaiting maintainer approval. The Windows +version matrix does not establish Linux CI success or a full theorem audit. diff --git a/research/cyclic-routing-performance/RESULT-python311.json b/research/cyclic-routing-performance/RESULT-python311.json new file mode 100644 index 0000000000..323dee6804 --- /dev/null +++ b/research/cyclic-routing-performance/RESULT-python311.json @@ -0,0 +1,224 @@ +{ + "benchmark_sha256": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "git": "git version 2.49.0.windows.1", + "logical_cpus": 16, + "machine": "AMD64", + "measured_utc": "2026-10-13T06:16:43.919114+00:00", + "medians": { + "after": { + "audit_cpu_seconds": 2.28125, + "audit_wall_seconds": 2.2882509999981266, + "process_wall_seconds": 2.553109600001335 + }, + "before": { + "audit_cpu_seconds": 3.15625, + "audit_wall_seconds": 3.16812199999913, + "process_wall_seconds": 3.43602550000287 + } + }, + "pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "platform": "Windows-10-10.0.19045-SP0", + "process_wall_speedup": 1.3458198190947517, + "processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel", + "python": "3.11.16 (main, Sep 1 2026, 14:15:24) [MSC v.1944 64 bit (AMD64)]", + "samples": [ + { + "audit_cpu_seconds": 3.140625, + "audit_wall_seconds": 3.1642443999990064, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 3.4300459000005503, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.265625, + "audit_wall_seconds": 2.270388000000821, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 2.538216699998884, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.28125, + "audit_wall_seconds": 2.2882509999981266, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 2.554900200000702, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.203125, + "audit_wall_seconds": 3.1992084000012255, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.4684332000033464, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.203125, + "audit_wall_seconds": 3.2249031999999715, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.4931427000010444, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.291423799997574, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 2.553109600001335, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.265625, + "audit_wall_seconds": 2.265632300001016, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 2.5302867999998853, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.15625, + "audit_wall_seconds": 3.154984400000103, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.426677600000403, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.234375, + "audit_wall_seconds": 3.2354314000003797, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.5037947999990138, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.291178799998306, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 2.553952999998728, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.28125, + "audit_wall_seconds": 2.272368699999788, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 2.5391491999980644, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.109375, + "audit_wall_seconds": 3.144745600002352, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 3.4163474999986647, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.15625, + "audit_wall_seconds": 3.16812199999913, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 3.43602550000287, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.301891400002205, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 2.5592355000007956, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "scope": "Complete historical certificate only; no selected-frontier or multiplication runtime claim. Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use tracemalloc in separate untimed processes and are not RSS.", + "separate_memory_samples": [ + { + "audit_cpu_seconds": 39.546875, + "audit_wall_seconds": 39.611298499999975, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 131095713, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 53.6875, + "audit_wall_seconds": 53.75630480000109, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 80506981, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "status": "PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS" +} diff --git a/research/cyclic-routing-performance/RESULT-python313.json b/research/cyclic-routing-performance/RESULT-python313.json new file mode 100644 index 0000000000..a55d3a1182 --- /dev/null +++ b/research/cyclic-routing-performance/RESULT-python313.json @@ -0,0 +1,224 @@ +{ + "benchmark_sha256": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "git": "git version 2.49.0.windows.1", + "logical_cpus": 16, + "machine": "AMD64", + "measured_utc": "2026-10-13T06:19:56.783556+00:00", + "medians": { + "after": { + "audit_cpu_seconds": 2.3125, + "audit_wall_seconds": 2.3183578999996826, + "process_wall_seconds": 2.9022320000003674 + }, + "before": { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.0372954000013124, + "process_wall_seconds": 3.628810700000031 + } + }, + "pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "platform": "Windows-10-10.0.19045-SP0", + "process_wall_speedup": 1.250351694833346, + "processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel", + "python": "3.13.15 (main, Sep 1 2026, 14:16:48) [MSC v.1944 64 bit (AMD64)]", + "samples": [ + { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.0372954000013124, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 3.628810700000031, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.29263759999958, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 2.887283000000025, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.333375199999864, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 2.91669069999989, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.0, + "audit_wall_seconds": 3.0093435999988287, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.610894499997812, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.051282900003571, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.6394919999984268, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.375, + "audit_wall_seconds": 2.3701780999981565, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 2.9638453999978083, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.390625, + "audit_wall_seconds": 2.399521999999706, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.003089399997407, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.125, + "audit_wall_seconds": 3.130459600000904, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.7320443999997224, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.026550999999017, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.6185484000016004, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.328125, + "audit_wall_seconds": 2.3142425999976695, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 2.9022320000003674, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.296875, + "audit_wall_seconds": 2.2867089999999735, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 2.8724752999987686, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.0, + "audit_wall_seconds": 3.0041885999999067, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 3.58943900000304, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.0427372999984073, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 3.632355000001553, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.3125, + "audit_wall_seconds": 2.3183578999996826, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 2.8996726000004855, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "scope": "Complete historical certificate only; no selected-frontier or multiplication runtime claim. Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use tracemalloc in separate untimed processes and are not RSS.", + "separate_memory_samples": [ + { + "audit_cpu_seconds": 42.84375, + "audit_wall_seconds": 43.019629300000815, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 131039569, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 61.4375, + "audit_wall_seconds": 61.504339600000094, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 80446681, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "status": "PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS" +} diff --git a/research/cyclic-routing-performance/RESULT-python314.json b/research/cyclic-routing-performance/RESULT-python314.json new file mode 100644 index 0000000000..cabf6414af --- /dev/null +++ b/research/cyclic-routing-performance/RESULT-python314.json @@ -0,0 +1,224 @@ +{ + "benchmark_sha256": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "git": "git version 2.49.0.windows.1", + "logical_cpus": 16, + "machine": "AMD64", + "measured_utc": "2026-10-13T06:22:48.691291+00:00", + "medians": { + "after": { + "audit_cpu_seconds": 2.53125, + "audit_wall_seconds": 2.529712700001255, + "process_wall_seconds": 3.198651399998198 + }, + "before": { + "audit_cpu_seconds": 3.1875, + "audit_wall_seconds": 3.197829799999454, + "process_wall_seconds": 3.8429650999969454 + } + }, + "pins": { + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "base_sha256": { + "certificates/cyclic-topology-audit.json": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "scripts/audit_cyclic_topology.py": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29" + }, + "dependencies_sha256": { + "docs/research/cyclic-topology-audit.md": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "scripts/audit_cancellation.py": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "scripts/audit_fused_block.py": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "scripts/audit_joint_frames.py": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/finite_bit_contract.py": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "platform": "Windows-10-10.0.19045-SP0", + "process_wall_speedup": 1.201432922637056, + "processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel", + "python": "3.14.7 (main, Sep 1 2026, 14:17:30) [MSC v.1944 64 bit (AMD64)]", + "samples": [ + { + "audit_cpu_seconds": 2.890625, + "audit_wall_seconds": 2.8986985000010463, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 3.533867799997097, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.375, + "audit_wall_seconds": 2.3736454999998386, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 0, + "process_wall_seconds": 2.989322900000843, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.5625, + "audit_wall_seconds": 2.5879965999993146, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.2037780999999086, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.203125, + "audit_wall_seconds": 3.2214299000006577, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 1, + "process_wall_seconds": 3.938786499998969, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.1875, + "audit_wall_seconds": 3.197829799999454, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.8429650999969454, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.484375, + "audit_wall_seconds": 2.4865049, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 2, + "process_wall_seconds": 3.149198200000683, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.53125, + "audit_wall_seconds": 2.529712700001255, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.17708710000079, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.9375, + "audit_wall_seconds": 2.959082199999102, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 3, + "process_wall_seconds": 3.615783100001863, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.109375, + "audit_wall_seconds": 3.107583100001648, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.7335316999997303, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.03125, + "audit_wall_seconds": 3.0539409999983036, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 4, + "process_wall_seconds": 3.6953634999990754, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.71875, + "audit_wall_seconds": 2.7110658999990846, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 3.4332883000024594, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.46875, + "audit_wall_seconds": 3.506362700001773, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 5, + "process_wall_seconds": 4.193912200000341, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 3.390625, + "audit_wall_seconds": 3.4181090999991284, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 4.203376699999353, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 2.5, + "audit_wall_seconds": 2.506347200000164, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "pair": 6, + "process_wall_seconds": 3.198651399998198, + "python_allocation_peak_bytes": null, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "scope": "Complete historical certificate only; no selected-frontier or multiplication runtime claim. Sequential alternating fresh processes; OS caches not flushed. Allocation peaks use tracemalloc in separate untimed processes and are not RSS.", + "separate_memory_samples": [ + { + "audit_cpu_seconds": 31.515625, + "audit_wall_seconds": 31.617805199999566, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "before", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 139552657, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + }, + { + "audit_cpu_seconds": 45.53125, + "audit_wall_seconds": 46.18131930000163, + "current_source_sha256": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "mode": "after", + "normalized_receipt_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "python_allocation_peak_bytes": 80350241, + "receipt_sha256": "3eec92964a82e5ecba261face343e845dde0408e7e9c827ea74fe15fea7e8be8" + } + ], + "status": "PASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS" +} diff --git a/research/cyclic-routing-performance/SELECTION.json b/research/cyclic-routing-performance/SELECTION.json index a0300152e4..e2a46d0621 100644 --- a/research/cyclic-routing-performance/SELECTION.json +++ b/research/cyclic-routing-performance/SELECTION.json @@ -31,7 +31,31 @@ "proof_scope": "Encoding and reachable-state equivalence argument; independent finite controls, not a formal multiplication theorem", "status": "Verified tooling contribution; ready for commit and one upstream PR" }, - "coordination": "No pinned sprint coordination issue visible; the only open non-PR issue was #650 (Discussions). Local claim; GitHub CLI currently unauthenticated.", + "continuation": { + "completed_utc": "2026-10-13T06:36:56.856524+00:00", + "evidence": [ + "VALIDATION-MATRIX.json", + "RESULT-python311.json", + "RESULT-python313.json", + "RESULT-python314.json" + ], + "latest_open_pr_checked": 820, + "overlap_checked_utc": "2026-10-13T06:23:12.824497+00:00", + "pr": 808, + "previous_pr_head": "b9c280c49d9c0c15f88c386286e6cd2a892efb67", + "result": "Full independent oracle at every depth cap 0 through 7 for all three widths; 14 tests on each CI Python version plus 14 under 3.14 -O; 48 further identical benchmark receipts.", + "scope": "Strengthen the same packed-routing contribution with full depth-seven independent literal-state validation and CI-version reproducibility. Do not expand the mathematical search domain.", + "scope_matches": "Only the existing PR808 among the 100 latest open PRs.", + "started_utc": "2026-10-13T06:09:43.487095+00:00", + "unchanged_input_files": 19, + "upstream_compatibility_commit": "7ee02b7c96d85f22b38d28bd7ed49bb8c1aeb261", + "versions": [ + "3.11.16", + "3.13.15", + "3.14.7" + ] + }, + "coordination": "No pinned sprint coordination issue visible; the only open non-PR issue was #650 (Discussions). Local claim; GitHub CLI was unauthenticated at the initial local claim; the authenticated delivery identity is recorded separately.", "delivery_identity": { "fork": "https://github.com/4RchYMing/integer-mult-bounds", "fork_push_permission": true, diff --git a/research/cyclic-routing-performance/VALIDATION-MATRIX.json b/research/cyclic-routing-performance/VALIDATION-MATRIX.json new file mode 100644 index 0000000000..44a2f21487 --- /dev/null +++ b/research/cyclic-routing-performance/VALIDATION-MATRIX.json @@ -0,0 +1,390 @@ +{ + "status": "PASS_FULL_DEPTH_SEVEN_AND_PYTHON_MATRIX", + "started_utc": "2026-10-13T06:13:46.052276+00:00", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "previous_pr_head": "b9c280c49d9c0c15f88c386286e6cd2a892efb67", + "platform": "Windows-10-10.0.19045-SP0", + "scope": "Independent dense-F2/literal-route oracle at EVERY depth cap 0 through 7 for widths 2, 3, 4, plus original finite-contract controls. Same-environment before/after benchmarks per Python version; no cross-version speed comparison.", + "source_sha256": { + "scripts/audit_cyclic_topology.py": "d8f91f6618adef8e080b2f4ee38531de972b1824590cd979c9ae9ce83a84f013", + "tests/test_cyclic_routing_packed.py": "fb215e9cd385e673b9c6e435eceff690216ee146a9d5c680ab097e7c06717d6b", + "tests/test_finite_bit_contract.py": "2e64760d4f080747a390ff256671958446366555dbfb449eb1bfa1b01e19468d", + "research/cyclic-routing-performance/benchmark.py": "454e4479e3ebc8954de3ee98167e7fa1261b67225513d2615aea1bff98d6e1e1", + "research/cyclic-routing-performance/SOURCE.json": "a39ad145eff6fc0622cdfaf9dbaa3529731e93b29c41e9e0260e1e07fa8ff9ca" + }, + "runs": [ + { + "version": "3.11", + "python": "3.11.16 (main, Sep 1 2026, 14:15:24) [MSC v.1944 64 bit (AMD64)]", + "checks": [ + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_cyclic_routing_packed.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 41.449308199997176, + "stdout": "", + "stderr": "test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok\ntest_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok\ntest_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok\ntest_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok\ntest_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok\n\n----------------------------------------------------------------------\nRan 5 tests in 41.155s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_finite_bit_contract.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 0.22771149999971385, + "stdout": "", + "stderr": "test_complete_role_permutation_and_orientation (test_finite_bit_contract.FiniteBitContract.test_complete_role_permutation_and_orientation) ... ok\ntest_exact_rational_schema_and_all_terminal_dimensions (test_finite_bit_contract.FiniteBitContract.test_exact_rational_schema_and_all_terminal_dimensions) ... ok\ntest_free_nonprojector_frames_and_gauge_invariance (test_finite_bit_contract.FiniteBitContract.test_free_nonprojector_frames_and_gauge_invariance) ... ok\ntest_nonpermutation_or_invalid_gate_cannot_be_scored (test_finite_bit_contract.FiniteBitContract.test_nonpermutation_or_invalid_gate_cannot_be_scored) ... ok\ntest_routing_certificates_cover_every_physical_edge (test_finite_bit_contract.FiniteBitContract.test_routing_certificates_cover_every_physical_edge) ... ok\ntest_scratch_roles_and_untouched_wire_edges_are_not_omitted (test_finite_bit_contract.FiniteBitContract.test_scratch_roles_and_untouched_wire_edges_are_not_omitted) ... ok\ntest_short_word_search_against_independent_enumeration (test_finite_bit_contract.FiniteBitContract.test_short_word_search_against_independent_enumeration) ... ok\ntest_small_role_closure_and_four_role_scope (test_finite_bit_contract.FiniteBitContract.test_small_role_closure_and_four_role_scope) ... ok\ntest_tampered_routes_and_exhausted_search_budget_rejected (test_finite_bit_contract.FiniteBitContract.test_tampered_routes_and_exhausted_search_budget_rejected) ... ok\n\n----------------------------------------------------------------------\nRan 9 tests in 0.038s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-B", + "research/cyclic-routing-performance/benchmark.py", + "--pairs", + "7", + "--out", + "research/cyclic-routing-performance/RESULT-python311.json" + ], + "exit_code": 0, + "elapsed_seconds": 136.13148290000026, + "stdout": "before 1 3.430046s\nafter 1 2.538217s\nafter 2 2.554900s\nbefore 2 3.468433s\nbefore 3 3.493143s\nafter 3 2.553110s\nafter 4 2.530287s\nbefore 4 3.426678s\nbefore 5 3.503795s\nafter 5 2.553953s\nafter 6 2.539149s\nbefore 6 3.416347s\nbefore 7 3.436026s\nafter 7 2.559236s\nbefore Python allocation peak 131095713\nafter Python allocation peak 80506981\nPASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS\n", + "stderr": "" + } + ], + "benchmark_file": "RESULT-python311.json" + }, + { + "version": "3.13", + "python": "3.13.15 (main, Sep 1 2026, 14:16:48) [MSC v.1944 64 bit (AMD64)]", + "checks": [ + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_cyclic_routing_packed.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 40.24206339999728, + "stdout": "", + "stderr": "test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok\ntest_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok\ntest_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok\ntest_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok\ntest_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok\n\n----------------------------------------------------------------------\nRan 5 tests in 39.707s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_finite_bit_contract.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 0.5351685999994515, + "stdout": "", + "stderr": "test_complete_role_permutation_and_orientation (test_finite_bit_contract.FiniteBitContract.test_complete_role_permutation_and_orientation) ... ok\ntest_exact_rational_schema_and_all_terminal_dimensions (test_finite_bit_contract.FiniteBitContract.test_exact_rational_schema_and_all_terminal_dimensions) ... ok\ntest_free_nonprojector_frames_and_gauge_invariance (test_finite_bit_contract.FiniteBitContract.test_free_nonprojector_frames_and_gauge_invariance) ... ok\ntest_nonpermutation_or_invalid_gate_cannot_be_scored (test_finite_bit_contract.FiniteBitContract.test_nonpermutation_or_invalid_gate_cannot_be_scored) ... ok\ntest_routing_certificates_cover_every_physical_edge (test_finite_bit_contract.FiniteBitContract.test_routing_certificates_cover_every_physical_edge) ... ok\ntest_scratch_roles_and_untouched_wire_edges_are_not_omitted (test_finite_bit_contract.FiniteBitContract.test_scratch_roles_and_untouched_wire_edges_are_not_omitted) ... ok\ntest_short_word_search_against_independent_enumeration (test_finite_bit_contract.FiniteBitContract.test_short_word_search_against_independent_enumeration) ... ok\ntest_small_role_closure_and_four_role_scope (test_finite_bit_contract.FiniteBitContract.test_small_role_closure_and_four_role_scope) ... ok\ntest_tampered_routes_and_exhausted_search_budget_rejected (test_finite_bit_contract.FiniteBitContract.test_tampered_routes_and_exhausted_search_budget_rejected) ... ok\n\n----------------------------------------------------------------------\nRan 9 tests in 0.038s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-B", + "research/cyclic-routing-performance/benchmark.py", + "--pairs", + "7", + "--out", + "research/cyclic-routing-performance/RESULT-python313.json" + ], + "exit_code": 0, + "elapsed_seconds": 152.0490917999996, + "stdout": "before 1 3.628811s\nafter 1 2.887283s\nafter 2 2.916691s\nbefore 2 3.610894s\nbefore 3 3.639492s\nafter 3 2.963845s\nafter 4 3.003089s\nbefore 4 3.732044s\nbefore 5 3.618548s\nafter 5 2.902232s\nafter 6 2.872475s\nbefore 6 3.589439s\nbefore 7 3.632355s\nafter 7 2.899673s\nbefore Python allocation peak 131039569\nafter Python allocation peak 80446681\nPASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS\n", + "stderr": "" + } + ], + "benchmark_file": "RESULT-python313.json" + }, + { + "version": "3.14", + "python": "3.14.7 (main, Sep 1 2026, 14:17:30) [MSC v.1944 64 bit (AMD64)]", + "checks": [ + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_cyclic_routing_packed.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 41.61136989999795, + "stdout": "", + "stderr": "test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok\ntest_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok\ntest_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok\ntest_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok\ntest_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok\n\n----------------------------------------------------------------------\nRan 5 tests in 40.970s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_finite_bit_contract.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 0.5540596999999252, + "stdout": "", + "stderr": "test_complete_role_permutation_and_orientation (test_finite_bit_contract.FiniteBitContract.test_complete_role_permutation_and_orientation) ... ok\ntest_exact_rational_schema_and_all_terminal_dimensions (test_finite_bit_contract.FiniteBitContract.test_exact_rational_schema_and_all_terminal_dimensions) ... ok\ntest_free_nonprojector_frames_and_gauge_invariance (test_finite_bit_contract.FiniteBitContract.test_free_nonprojector_frames_and_gauge_invariance) ... ok\ntest_nonpermutation_or_invalid_gate_cannot_be_scored (test_finite_bit_contract.FiniteBitContract.test_nonpermutation_or_invalid_gate_cannot_be_scored) ... ok\ntest_routing_certificates_cover_every_physical_edge (test_finite_bit_contract.FiniteBitContract.test_routing_certificates_cover_every_physical_edge) ... ok\ntest_scratch_roles_and_untouched_wire_edges_are_not_omitted (test_finite_bit_contract.FiniteBitContract.test_scratch_roles_and_untouched_wire_edges_are_not_omitted) ... ok\ntest_short_word_search_against_independent_enumeration (test_finite_bit_contract.FiniteBitContract.test_short_word_search_against_independent_enumeration) ... ok\ntest_small_role_closure_and_four_role_scope (test_finite_bit_contract.FiniteBitContract.test_small_role_closure_and_four_role_scope) ... ok\ntest_tampered_routes_and_exhausted_search_budget_rejected (test_finite_bit_contract.FiniteBitContract.test_tampered_routes_and_exhausted_search_budget_rejected) ... ok\n\n----------------------------------------------------------------------\nRan 9 tests in 0.037s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-B", + "research/cyclic-routing-performance/benchmark.py", + "--pairs", + "7", + "--out", + "research/cyclic-routing-performance/RESULT-python314.json" + ], + "exit_code": 0, + "elapsed_seconds": 129.70277260000148, + "stdout": "before 1 3.533868s\nafter 1 2.989323s\nafter 2 3.203778s\nbefore 2 3.938786s\nbefore 3 3.842965s\nafter 3 3.149198s\nafter 4 3.177087s\nbefore 4 3.615783s\nbefore 5 3.733532s\nafter 5 3.695363s\nafter 6 3.433288s\nbefore 6 4.193912s\nbefore 7 4.203377s\nafter 7 3.198651s\nbefore Python allocation peak 139552657\nafter Python allocation peak 80350241\nPASS_IDENTICAL_COMPLETE_ROUTING_RECEIPTS\n", + "stderr": "" + } + ], + "benchmark_file": "RESULT-python314.json" + }, + { + "version": "3.14 optimized", + "python": "3.14.7 (main, Sep 1 2026, 14:17:30) [MSC v.1944 64 bit (AMD64)]", + "checks": [ + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-O", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_cyclic_routing_packed.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 54.68270539999867, + "stdout": "", + "stderr": "test_complete_frozen_frontiers_and_receipts (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_complete_frozen_frontiers_and_receipts) ... ok\ntest_dense_scalar_and_literal_routing_oracle (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_dense_scalar_and_literal_routing_oracle) ... ok\ntest_depth_cutoff_is_not_closure (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_depth_cutoff_is_not_closure) ... ok\ntest_invalid_widths_and_depths_still_raise (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_invalid_widths_and_depths_still_raise) ... ok\ntest_scalar_only_merge_loses_coverage_without_finding_a_survivor (test_cyclic_routing_packed.CyclicRoutingPackedTest.test_scalar_only_merge_loses_coverage_without_finding_a_survivor) ... ok\n\n----------------------------------------------------------------------\nRan 5 tests in 53.924s\n\nOK\n" + }, + { + "command": [ + "", + "-X", + "utf8", + "-I", + "-B", + "-O", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_finite_bit_contract.py", + "-v" + ], + "exit_code": 0, + "elapsed_seconds": 0.7447849000018323, + "stdout": "", + "stderr": "test_complete_role_permutation_and_orientation (test_finite_bit_contract.FiniteBitContract.test_complete_role_permutation_and_orientation) ... ok\ntest_exact_rational_schema_and_all_terminal_dimensions (test_finite_bit_contract.FiniteBitContract.test_exact_rational_schema_and_all_terminal_dimensions) ... ok\ntest_free_nonprojector_frames_and_gauge_invariance (test_finite_bit_contract.FiniteBitContract.test_free_nonprojector_frames_and_gauge_invariance) ... ok\ntest_nonpermutation_or_invalid_gate_cannot_be_scored (test_finite_bit_contract.FiniteBitContract.test_nonpermutation_or_invalid_gate_cannot_be_scored) ... ok\ntest_routing_certificates_cover_every_physical_edge (test_finite_bit_contract.FiniteBitContract.test_routing_certificates_cover_every_physical_edge) ... ok\ntest_scratch_roles_and_untouched_wire_edges_are_not_omitted (test_finite_bit_contract.FiniteBitContract.test_scratch_roles_and_untouched_wire_edges_are_not_omitted) ... ok\ntest_short_word_search_against_independent_enumeration (test_finite_bit_contract.FiniteBitContract.test_short_word_search_against_independent_enumeration) ... ok\ntest_small_role_closure_and_four_role_scope (test_finite_bit_contract.FiniteBitContract.test_small_role_closure_and_four_role_scope) ... ok\ntest_tampered_routes_and_exhausted_search_budget_rejected (test_finite_bit_contract.FiniteBitContract.test_tampered_routes_and_exhausted_search_budget_rejected) ... ok\n\n----------------------------------------------------------------------\nRan 9 tests in 0.043s\n\nOK\n" + } + ] + } + ], + "completed_utc": "2026-10-13T06:23:44.314131+00:00", + "upstream_compatibility": { + "status": "PASS_UNCHANGED_VERIFIER_INPUTS", + "checked_utc": "2026-10-13T06:25:46.659530+00:00", + "upstream_main": "7ee02b7c96d85f22b38d28bd7ed49bb8c1aeb261", + "original_base": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "scope": "Byte comparison of every pinned input, the original checker/certificate, finite-contract tests, test runner, and general CI workflow. Not a cold replay of the new selected frontier.", + "files": [ + { + "path": "docs/research/cyclic-topology-audit.md", + "expected_sha256": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "upstream_sha256": "156f3bc880738b1a6d378fd5d1d97297fd1ae457eb71160690ccb1cc1f42fc4c", + "matches": true + }, + { + "path": "scripts/audit_cancellation.py", + "expected_sha256": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "upstream_sha256": "508934ee4d9514a5519813603b6192a0d53103b6e30d65b8d53a1a774de244b6", + "matches": true + }, + { + "path": "scripts/audit_fused_block.py", + "expected_sha256": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "upstream_sha256": "2afb83ca8e5f193ca8a4c242becf267ad1d9dc2578ba238b820e98d5185f6288", + "matches": true + }, + { + "path": "scripts/audit_joint_frames.py", + "expected_sha256": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "upstream_sha256": "3df8061392ce0ba42bbde8c02f2a30c8141145e70e9a48c18da73d3aafb14423", + "matches": true + }, + { + "path": "scripts/certify.py", + "expected_sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "upstream_sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "matches": true + }, + { + "path": "scripts/exclusion_circuit.py", + "expected_sha256": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "upstream_sha256": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "matches": true + }, + { + "path": "scripts/finite_bit_contract.py", + "expected_sha256": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "upstream_sha256": "3cff26a332cb6056f656b824e3a523fb8937d15206ddcc4118b911ac8df1b2a7", + "matches": true + }, + { + "path": "scripts/paired_exclusion_circuit.py", + "expected_sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "upstream_sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "matches": true + }, + { + "path": "scripts/paired_network.py", + "expected_sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "upstream_sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "matches": true + }, + { + "path": "scripts/prepare_layers.py", + "expected_sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "upstream_sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "matches": true + }, + { + "path": "scripts/search_network.py", + "expected_sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "upstream_sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "matches": true + }, + { + "path": "scripts/shared_point_circuit.py", + "expected_sha256": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "upstream_sha256": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "matches": true + }, + { + "path": "scripts/shared_point_network.py", + "expected_sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "upstream_sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "matches": true + }, + { + "path": "upstream/manifest.json", + "expected_sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "upstream_sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "matches": true + }, + { + "path": "certificates/cyclic-topology-audit.json", + "expected_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "upstream_sha256": "65c8ee98e7d2d032ffb8f6eaa3cc57babe5fa7df129115ae1a83dc1fd2e9d607", + "matches": true + }, + { + "path": "scripts/audit_cyclic_topology.py", + "expected_sha256": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29", + "upstream_sha256": "b20ece2cf1337e1808e35b602a0120c6aedaf602fa2315560726a149e9838c29", + "matches": true + }, + { + "path": "tests/test_finite_bit_contract.py", + "expected_sha256": "2e64760d4f080747a390ff256671958446366555dbfb449eb1bfa1b01e19468d", + "upstream_sha256": "2e64760d4f080747a390ff256671958446366555dbfb449eb1bfa1b01e19468d", + "matches": true + }, + { + "path": "scripts/run_isolated_tests.py", + "expected_sha256": "b5c38b4f4f5e967ccda5f95702d18d6f01c18d43f056bb419aaf1628043c6ecc", + "upstream_sha256": "b5c38b4f4f5e967ccda5f95702d18d6f01c18d43f056bb419aaf1628043c6ecc", + "matches": true + }, + { + "path": ".github/workflows/verify.yml", + "expected_sha256": "0b0ebae2889ce3f73a620fff094f9720847d19ec553512c905397f4c8f2d3989", + "upstream_sha256": "0b0ebae2889ce3f73a620fff094f9720847d19ec553512c905397f4c8f2d3989", + "matches": true + } + ] + }, + "limitations": "Windows-only local matrix; upstream Linux CI needs maintainer approval. Both oracles share the documented finite-state reduction and saturation rule. No selected-frontier cold replay or all-length four-role result." +} diff --git a/tests/test_cyclic_routing_packed.py b/tests/test_cyclic_routing_packed.py index a1b8c75bdf..0014d5eb2a 100644 --- a/tests/test_cyclic_routing_packed.py +++ b/tests/test_cyclic_routing_packed.py @@ -85,7 +85,7 @@ def test_complete_frozen_frontiers_and_receipts(self): self.assertEqual(routing_state_search(expected['W'], 7), expected) def test_dense_scalar_and_literal_routing_oracle(self): - for width, cap in [(2, 7), (3, 7), (4, 4)]: + for width, cap in [(2, 7), (3, 7), (4, 7)]: for depth in range(cap + 1): with self.subTest(width=width, depth=depth): expected = literal_search(width, depth)