diff --git a/research/complex-frame-plane-rail-seedca04cc/BEST-WORD.json.gz b/research/complex-frame-plane-rail-seedca04cc/BEST-WORD.json.gz new file mode 100644 index 0000000000..38ecba18ed Binary files /dev/null and b/research/complex-frame-plane-rail-seedca04cc/BEST-WORD.json.gz differ diff --git a/research/complex-frame-plane-rail-seedca04cc/CLAIM.md b/research/complex-frame-plane-rail-seedca04cc/CLAIM.md new file mode 100644 index 0000000000..d880b3141c --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/CLAIM.md @@ -0,0 +1,64 @@ +# Cycle 15 claim + +Track `complex-mechanisms`; seed `ca04ccbf3c8c214a13d9c2452e780d32`; +`complex-rank-shape-decoder`; priority revision 3; base +`0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 +`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. + +Question: can a single canonical two-coordinate plane be introduced at one +helper-to-helper addition of the selected PR1094 native local word and propagated +forward by the inclusion-minimal common-frame closure, with every scalar gate, +start frame, exact A/B target-level and centre-frame boundary, target endpoint, +and dirty-helper endpoint fixed? Search all 36 +coordinate two-planes and every helper-to-helper A/B addition. Price every +induced child rank and reject endpoint changes. The deliverable is the exact +best profile and fixed-template ceiling over this finite domain, with closure +and endpoint controls. The 10%-mass-to-rank-9 favorable screen is only 1.04318x; +this search must cover the whole word to have a chance at the required 5%. + +Pinned word is member +`candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz` of +`research/community-frontier1094-audit/selected-replay.tar.gz` (archive SHA-256 +`f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6`, member +SHA-256 `49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289`); +its selected profile is `{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}`. + +Relevant predecessors: selected provider PR #1094; PR #699 and +`complex-sw4-frame8` for isolated B-frame coalescences; PR #1429 for the +fixed late-block interface optimum; PR #1517 for cross-block communication +under that interface. Adjacent open PR #1186 provides an exact frame solver +and delivery-rewrite search for an older PR #1148 joint-entrance k8 word; +this claim tests a one-plane forced closure on the selected PR1094 word. +The 2026-10-14 16:23:08 UTC overlap refresh covered all 433 open PRs and 618 +discussions. The later 16:29:05 UTC refresh covered 438 open PRs and 619 +discussions; five text matches were our two claim comments, one +plane-port discussion thread, and two local background documents. Manual review +found open PR #1186 (frame solver and delivery rewrites for an older word), +PR #1825 (paired plane-port decoder on selected labels), and PR #1900 (five +plane queries for the P111 bit decoder). PRs #1825 and #1900 change the +coverage contract/decoder; this claim keeps coverage and helper inventory fixed +and changes only internal frame timing. Discussion claim #18924772 poses the +plane-port question behind those decoder routes. Nearby #18924220, #1909, and +#1622 concern a Cartesian input-output grid, tetrad-local masks, and a ten-term +decoder, respectively. + +No scalar operation or helper is added. A surviving schedule is a new paid +rank distribution only if the exact closure retains all pinned internal and +terminal interfaces. +Correction: the initial version of this claim used the older PR699 word and +was released in comment #18926956 before any package or submission. This +replacement claim uses the current selected PR1094 word above. It expires +2026-10-14 17:18:00 UTC. + +Interim correction: the first selected-word sweep preserved terminal endpoints +but did not enforce the exact A/B target-level and centre-frame barrier; the +independent native audit rejected its best candidate. Those provisional counts +and profiles are discarded. The search now includes both exact interface +barriers before any candidate can enter the result. + +Final finding: complete coverage of all 90,900 pairs yields 569 no-ops, 89,737 +interface/endpoint conflicts, and 594 valid closures over 13 exact rank +profiles. The exact maximum ceiling equals the selected baseline bracket and +does not clear the 5% gate; the best candidate passes the pinned independent +native audit. Reproduction and the bounded conclusion are packaged at +`research/complex-frame-plane-rail-seedca04cc/`. No new κ is claimed. diff --git a/research/complex-frame-plane-rail-seedca04cc/NATIVE-AUDIT.json b/research/complex-frame-plane-rail-seedca04cc/NATIVE-AUDIT.json new file mode 100644 index 0000000000..a15b96a22a --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/NATIVE-AUDIT.json @@ -0,0 +1,32 @@ +{ + "status": "PASS_INDEPENDENT_EXACT_FORWARD_AND_DUAL_ENDPOINT_FRAMES_ENTRANCES_CONES", + "input_file": "BEST-WORD.json.gz", + "content_sha256": "35dba4d11d0bafe1a2f3a19290a850a681f8c2de1b29ec4fe6516ece5791c428", + "compressed_sha256": "13a8e666069311175608b83768bb0b377f43805c7677c33ccc9b944f2e3cdae0", + "parent_center_interface": null, + "v": 112, + "h": 9, + "R": 480, + "entering": 192, + "lowends": 78, + "coldends": 48, + "compensation_gates": 7208, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "width_inventory": { + "4": 56, + "5": 32, + "7": 30, + "8": 122, + "9": 240 + }, + "checked_columns": 704, + "elapsed_seconds": 0.9026521999985562, + "scope": "Exact rational full scalar map in both orientations; all literal native frame chains, center levels, dyadic units, entrance-zero response, wrapper exclusion and final helper row/column cones. No global owner admission or exponent repricing." +} diff --git a/research/complex-frame-plane-rail-seedca04cc/PROOF.md b/research/complex-frame-plane-rail-seedca04cc/PROOF.md new file mode 100644 index 0000000000..ce0a53ac13 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/PROOF.md @@ -0,0 +1,27 @@ +# Finite closure and ceiling argument + +## Claim + +For the pinned selected PR1094 local word, the 36 coordinate subspaces `P = span(e_i,e_j)` and each eligible helper-helper A/B gate have been exhaustively considered as a one-time plane injection followed by least common-frame propagation. Among closures preserving the original exact A/B target-level and centre-frame interfaces and all final endpoints, the best paid profile has exactly the selected baseline profile. Thus this mechanism, in this finite domain and under the fixed-template model, gives no ceiling improvement, in particular not the catalogue's required 5% improvement. + +The claim is about this word and this family of frame schedules only. + +## Least closure and cost + +The replay constructs an ordered list of events from the selected word. It includes scalar gates in A and B, then inserts the exact target-level and centre-frame constraints at their A/B boundary, followed by cleanup events and every final target or helper endpoint. Each event records its original output frame `F` and the incoming frames of its participating registers. + +After injecting `P` at a selected helper-helper gate, any later gate reached by an active register must place both gate operands in a common output frame that contains the original `F` and `P`. The least such frame is `span(F,P)`. The enumerator assigns exactly that frame, updates both participants, and keeps propagation active precisely when the augmented output still has a new dimension beyond `F`. If a target-level, centre-frame, or final endpoint does not already contain `P`, the schedule is rejected. This is a direct monotone event replay: it neither skips an induced climb nor adds a frame dimension not forced by the seeded plane and gate. + +At each changed event, the script replaces the original per-register climb ranks by the exact new ranks `dim(span(F,P)) - dim(incoming_frame)`, including both gate operands. The original chain profile is decomposed into these gate/interface/endpoint climbs and a checked fixed remainder of eight rank-8 units. The new chain profile is added back to that fixed remainder. It verifies that total paid rank mass is conserved when the same exact endpoints are retained. + +## Exhaustion and controls + +There are `binom(9,2)=36` coordinate planes and 2,525 eligible helper-helper additions in A/B, so the enumerated domain has 90,900 plane/gate pairs. There are 90,331 non-noop pairs. Of these, 89,737 violate an exact internal interface or final endpoint; 56,830 of the rejections occur at an internal target-level or centre-frame barrier. The remaining 594 closures are priced. They realize 13 distinct profiles. A saved negative-control witness injects `[1,2]` at event 0 and reaches register 60's exact centre frame at event 3563, which does not contain `[1,2]`; this pair must be rejected. + +The profile search uses the exact interval arithmetic in pinned `complex-local-word-ceiling/ceiling.py` for the 5%-above-baseline gate and for each surviving profile's ceiling. The floating bisection in `search.py` only chooses which closure to serialize; the exact ceiling intervals over all 13 profiles independently certify that the selected profile is the maximum and strictly separate it from the other 12. The best profile is the original profile, and its exact ceiling bracket equals the exact baseline bracket. Its lower endpoint is `1690054109/10^12`; the largest other-profile upper endpoint is `1690012017/10^12`, leaving a strict gap of `42092/10^12`. + +## Independent native check + +`BEST-WORD.json.gz` serializes the best closure while retaining the selected scalar program. The pinned `gauge44-slots/independent/audit_local.py` independently checks the exact scalar map in both orientations, all literal frame chains, centre levels, dyadic units, entrance-zero response, wrapper exclusion, and final helper row/column cones. Its receipt records the same paid profile and selected dimensions. The verifier also changes the candidate's claimed rank-1 paid count by one and requires the native auditor to reject it with `paid profile mismatch`. + +This native audit is local evidence for the candidate. It is not global owner admission, full supplier reproving, or an exponent reprice. The no-improvement conclusion follows only from the bounded exact profile enumeration and the pinned fixed-template ceiling model. diff --git a/research/complex-frame-plane-rail-seedca04cc/README.md b/research/complex-frame-plane-rail-seedca04cc/README.md new file mode 100644 index 0000000000..c408ad2f8c --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/README.md @@ -0,0 +1,36 @@ +# Coordinate-plane temporal frame rail (seed `ca04ccbf`) + +**Outcome: scoped negative result. No new conditional bound or supplier admission is claimed.** + +## Question and result + +The selected PR1094 word has local paid profile `{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}`. This experiment changed frame timing: inject one coordinate two-plane at one helper-to-helper addition, then propagate the least common-frame closure through later gates. It held the scalar program, helper inventory, start frames, exact A/B target-level and centre-frame interfaces, and all final target and dirty-helper endpoints fixed. Every induced climb was priced at its actual rank. + +The complete domain is 36 coordinate two-planes by 2,525 eligible seed gates (90,900 pairs). The exact result is 569 no-ops, 89,737 endpoint or internal-interface conflicts, and 594 valid schedules over 13 distinct rank profiles. None reaches the task's 5% ceiling improvement. The highest profile is exactly the baseline profile, with ceiling bracket `[1690054109/10^12, 169005411/10^11]`. Its lower endpoint exceeds the largest other profile's upper endpoint, `1690012017/10^12`, by `42092/10^12`. The best candidate word passes the pinned independent exact native audit. + +This closes only the coordinate-plane, single-injection subfamily on this exact word. The first exploratory sweep omitted internal A/B interface barriers and its candidate failed the native audit; that sweep was discarded. The packaged rerun includes both exact target-level and centre-frame barriers, and the counterexample control exercises a centre-frame conflict. No global κ, asymptotic improvement, or general impossibility statement follows. + +The selected result is resolved from `certificates/selected-result.json`; source identity and base commit `0b1cccf86e2f5132ed286a26ef0a681a495740ea` are pinned in [SOURCES.json](SOURCES.json). The actual word is member `candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz` of the pinned selected replay archive, not the historical PR699 word. + +## Reproduce + +From the repository root: + +```sh +python3 scripts/research_package.py --package research/complex-frame-plane-rail-seedca04cc --check-only +python3.12 scripts/research_package.py --package research/complex-frame-plane-rail-seedca04cc +``` + +The registered replay reruns all 90,900 cases, compares the exact evidence, audits the committed candidate, and verifies that corrupting its claimed paid histogram is rejected. It needs no third-party packages. On systems without Python 3.12, run `python3 -B research/complex-frame-plane-rail-seedca04cc/verify.py` directly; the package metadata check still requires 3.12 for the repository's generic replay. + +## Proof and cost accounting + +See [PROOF.md](PROOF.md) for the closure invariant, completeness of the finite enumerator, exact interval comparison, and limits. All state and arithmetic needed for the claim are in `SEARCH.json`, `BEST-WORD.json.gz`, and `NATIVE-AUDIT.json`. + +## Open next questions + +Can a non-coordinate two-dimensional subspace of `F2^9` beat the selected ceiling under the same one-gate closure and exact interface constraints? There are 43,435 such subspaces in total. The first useful step is to compute the automorphism group preserving the pinned gate supports and interfaces, then quotient this Grassmannian before screening representatives. This run does not cover that domain. + +## Predecessors and credit + +The source is the selected complex provider associated with PR #1094. PR #699 and `research/complex-sw4-frame8` provide historical frame-coalescence context; PR #1429 studies a fixed late-block rank optimum; PR #1517 studies a cross-block floor under that interface. Adjacent open PR #1186 supplies an exact frame solver and delivery-rewrite search for an older PR #1148 word. Open PR #1825 investigates a paired plane-port decoder on selected E8 labels, while PR #1900 studies five plane queries for the P111 bit decoder. Those constructions change the coverage contract or decoder. This package instead tests forced coordinate-plane propagation on the selected PR1094 word with its coverage, helper inventory, and exact interfaces fixed. Source-specific notices remain with their pinned files. New research artifacts are Apache-2.0. OpenAI Codex autonomously designed, implemented, and packaged this experiment; see [TASK.json](TASK.json) for disclosure. diff --git a/research/complex-frame-plane-rail-seedca04cc/SEARCH.json b/research/complex-frame-plane-rail-seedca04cc/SEARCH.json new file mode 100644 index 0000000000..ca8ccc9989 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/SEARCH.json @@ -0,0 +1,2581 @@ +{ + "status": "PASS_TWO_PLANE_FRAME_RAIL_SEARCH", + "seed": "ca04ccbf3c8c214a13d9c2452e780d32", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_source_archive_sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "word_member": "candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz", + "word_sha256": "49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289", + "search_domain": { + "planes": 36, + "helper_helper_seed_gates": 2525, + "seed_plane_pairs": 90900 + }, + "totals": { + "tested": 90331, + "no_op": 569, + "endpoint_reject": 89737, + "interface_reject": 56830, + "below_5pct": 594, + "above_5pct": 0, + "ambiguous": 0 + }, + "best": { + "approx_a": 0.001690054108621553, + "seed_event": 4989, + "plane": [ + 1, + 2 + ], + "profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "rank_mass": 5586, + "ceiling_bracket": [ + "1690054109/1000000000000", + "169005411/100000000000" + ], + "target_a_5pct": "3549113631/2000000000000", + "target_relax_interval": [ + "115820506126293703594754082272648467472399011160437955794779799738836836540073/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "115820506126293703594754082272648467472399011160437955794779799738836836540109/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "profile_sha256": "196087de779f1f7f812b938982305bfafbd7fd4447800543e9b46edad7adebad", + "word_output_sha256": "35dba4d11d0bafe1a2f3a19290a850a681f8c2de1b29ec4fe6516ece5791c428" + }, + "base_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "base_ceiling_bracket": [ + "1690054109/1000000000000", + "169005411/100000000000" + ], + "distinct_valid_profiles": 13, + "exact_profile_ceilings": [ + { + "profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "bracket": [ + "1690054109/1000000000000", + "169005411/100000000000" + ] + }, + { + "profile": { + "1": 2411, + "2": 420, + "3": 431, + "4": 142, + "5": 82, + "8": 8 + }, + "bracket": [ + "105625751/62500000000", + "1690012017/1000000000000" + ] + }, + { + "profile": { + "1": 2414, + "2": 417, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "bracket": [ + "105621397/62500000000", + "1689942353/1000000000000" + ] + }, + { + "profile": { + "1": 2413, + "2": 419, + "3": 431, + "4": 142, + "5": 82, + "8": 8 + }, + "bracket": [ + "337980053/200000000000", + "844950133/500000000000" + ] + }, + { + "profile": { + "1": 2416, + "2": 416, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "bracket": [ + "168983061/100000000000", + "1689830611/1000000000000" + ] + }, + { + "profile": { + "1": 2418, + "2": 418, + "3": 436, + "4": 140, + "5": 80, + "8": 8 + }, + "bracket": [ + "1688927223/1000000000000", + "211115903/125000000000" + ] + }, + { + "profile": { + "1": 2419, + "2": 418, + "3": 436, + "4": 141, + "5": 79, + "8": 8 + }, + "bracket": [ + "844363021/500000000000", + "1688726043/1000000000000" + ] + }, + { + "profile": { + "1": 2418, + "2": 419, + "3": 436, + "4": 142, + "5": 78, + "8": 8 + }, + "bracket": [ + "844318239/500000000000", + "1688636479/1000000000000" + ] + }, + { + "profile": { + "1": 2412, + "2": 428, + "3": 434, + "4": 138, + "5": 80, + "8": 8 + }, + "bracket": [ + "1688620497/1000000000000", + "844310249/500000000000" + ] + }, + { + "profile": { + "1": 2420, + "2": 418, + "3": 436, + "4": 142, + "5": 78, + "8": 8 + }, + "bracket": [ + "1688524909/1000000000000", + "168852491/100000000000" + ] + }, + { + "profile": { + "1": 2412, + "2": 429, + "3": 435, + "4": 138, + "5": 79, + "8": 8 + }, + "bracket": [ + "844175059/500000000000", + "1688350119/1000000000000" + ] + }, + { + "profile": { + "1": 2411, + "2": 429, + "3": 437, + "4": 138, + "5": 78, + "8": 8 + }, + "bracket": [ + "1688233337/1000000000000", + "844116669/500000000000" + ] + }, + { + "profile": { + "1": 2412, + "2": 430, + "3": 436, + "4": 138, + "5": 78, + "8": 8 + }, + "bracket": [ + "67523193/40000000000", + "844039913/500000000000" + ] + } + ], + "plane_rows": [ + { + "tested": 2494, + "no_op": 31, + "endpoint_reject": 2490, + "interface_reject": 1663, + "below_5pct": 4, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 3, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2413, + 419, + 431, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 2 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2494, + "no_op": 31, + "endpoint_reject": 2492, + "interface_reject": 1663, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 4 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2497, + "no_op": 28, + "endpoint_reject": 2495, + "interface_reject": 1663, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 1, + "profiles": [ + [ + 0, + 2413, + 419, + 431, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 8 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2497, + "no_op": 28, + "endpoint_reject": 2497, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 16 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2521, + "no_op": 4, + "endpoint_reject": 2511, + "interface_reject": 1663, + "below_5pct": 10, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 3, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2413, + 419, + 431, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 32 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2521, + "no_op": 4, + "endpoint_reject": 2517, + "interface_reject": 1663, + "below_5pct": 4, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 64 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2481, + "no_op": 44, + "endpoint_reject": 2477, + "interface_reject": 1663, + "below_5pct": 4, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 128 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2481, + "no_op": 44, + "endpoint_reject": 2477, + "interface_reject": 1663, + "below_5pct": 4, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 1, + 256 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2493, + "no_op": 32, + "endpoint_reject": 2493, + "interface_reject": 1499, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 4 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2515, + "no_op": 10, + "endpoint_reject": 2515, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 8 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2515, + "no_op": 10, + "endpoint_reject": 2515, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 16 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2524, + "no_op": 1, + "endpoint_reject": 2522, + "interface_reject": 1663, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 32 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2519, + "interface_reject": 1663, + "below_5pct": 6, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2411, + 420, + 431, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2414, + 417, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 64 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2511, + "no_op": 14, + "endpoint_reject": 2509, + "interface_reject": 1499, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 128 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2513, + "no_op": 12, + "endpoint_reject": 2511, + "interface_reject": 1499, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 2, + 256 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2515, + "no_op": 10, + "endpoint_reject": 2515, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 8 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2503, + "no_op": 22, + "endpoint_reject": 2503, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 16 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2524, + "no_op": 1, + "endpoint_reject": 2522, + "interface_reject": 1663, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 32 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2523, + "no_op": 2, + "endpoint_reject": 2517, + "interface_reject": 1663, + "below_5pct": 6, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2411, + 420, + 431, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2414, + 417, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 64 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2495, + "no_op": 30, + "endpoint_reject": 2493, + "interface_reject": 1499, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 128 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2497, + "no_op": 28, + "endpoint_reject": 2495, + "interface_reject": 1499, + "below_5pct": 2, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 2, + "profiles": [ + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 4, + 256 + ], + "endpoint_event": 3564, + "registers": [ + 61 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2499, + "no_op": 26, + "endpoint_reject": 2467, + "interface_reject": 1597, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 8, + 16 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2525, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 8, + 32 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2525, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 8, + 64 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2507, + "no_op": 18, + "endpoint_reject": 2475, + "interface_reject": 1597, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 8, + 128 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2507, + "no_op": 18, + "endpoint_reject": 2475, + "interface_reject": 1597, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 8, + 256 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2525, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 16, + 32 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2525, + "interface_reject": 1663, + "below_5pct": 0, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 0, + "profiles": [], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 16, + 64 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2491, + "no_op": 34, + "endpoint_reject": 2459, + "interface_reject": 1597, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2411, + 429, + 437, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 428, + 434, + 138, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 429, + 435, + 138, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 430, + 436, + 138, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 16, + 128 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2491, + "no_op": 34, + "endpoint_reject": 2459, + "interface_reject": 1597, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2411, + 429, + 437, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 428, + 434, + 138, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 429, + 435, + 138, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 430, + 436, + 138, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 16, + 256 + ], + "endpoint_event": 3566, + "registers": [ + 224 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 17, + 9, + 5, + 3 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2521, + "no_op": 4, + "endpoint_reject": 2489, + "interface_reject": 1618, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 32, + 64 + ], + "endpoint_event": 3567, + "registers": [ + 31 + ], + "endpoint_frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2493, + "interface_reject": 1618, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 32, + 128 + ], + "endpoint_event": 3567, + "registers": [ + 31 + ], + "endpoint_frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2493, + "interface_reject": 1618, + "below_5pct": 32, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 4, + "profiles": [ + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 32, + 256 + ], + "endpoint_event": 3567, + "registers": [ + 31 + ], + "endpoint_frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2481, + "interface_reject": 1618, + "below_5pct": 44, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 6, + "profiles": [ + [ + 0, + 2411, + 429, + 437, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 428, + 434, + 138, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 429, + 435, + 138, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 430, + 436, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 64, + 128 + ], + "endpoint_event": 3567, + "registers": [ + 31 + ], + "endpoint_frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2525, + "no_op": 0, + "endpoint_reject": 2481, + "interface_reject": 1618, + "below_5pct": 44, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 6, + "profiles": [ + [ + 0, + 2411, + 429, + 437, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 428, + 434, + 138, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 429, + 435, + 138, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 430, + 436, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 64, + 256 + ], + "endpoint_event": 3567, + "registers": [ + 31 + ], + "endpoint_frame": [ + 256, + 128, + 65, + 33, + 17, + 9, + 4, + 2 + ], + "boundary_kind": "center_frame" + } + }, + { + "tested": 2476, + "no_op": 49, + "endpoint_reject": 2280, + "interface_reject": 0, + "below_5pct": 196, + "above_5pct": 0, + "ambiguous": 0, + "unique_profiles": 10, + "profiles": [ + [ + 0, + 2411, + 429, + 437, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 418, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 428, + 434, + 138, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 429, + 435, + 138, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2412, + 430, + 436, + 138, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2416, + 416, + 432, + 142, + 82, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 418, + 436, + 140, + 80, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2418, + 419, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2419, + 418, + 436, + 141, + 79, + 0, + 0, + 8, + 0 + ], + [ + 0, + 2420, + 418, + 436, + 142, + 78, + 0, + 0, + 8, + 0 + ] + ], + "first_endpoint_control": { + "seed_event": 0, + "plane": [ + 128, + 256 + ], + "endpoint_event": 5646, + "registers": [ + 113 + ], + "endpoint_frame": [ + 257, + 129, + 64, + 32, + 17, + 8, + 5, + 2 + ], + "boundary_kind": "final" + } + } + ], + "exact_best_separation": { + "best_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "best_lower": "1690054109/1000000000000", + "max_other_upper": "1690012017/1000000000000", + "strictly_separated": true + }, + "negative_control": { + "kind": "exact internal interface barrier conflict", + "example": { + "seed_event": 0, + "plane": [ + 1, + 2 + ], + "endpoint_event": 3563, + "registers": [ + 60 + ], + "endpoint_frame": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2 + ], + "boundary_kind": "center_frame" + }, + "rejected_seed_plane_pairs": 89737, + "interface_rejections": 56830 + }, + "construction_effect": { + "scalar_program_unchanged": true, + "start_frames_unchanged": true, + "A_B_target_levels_and_centres_exact": true, + "terminal_endpoints_unchanged": true, + "additional_arrays": 0, + "additional_scalar_gates": 0, + "all_induced_rank_climbs_charged": true + } +} diff --git a/research/complex-frame-plane-rail-seedca04cc/SOURCES.json b/research/complex-frame-plane-rail-seedca04cc/SOURCES.json new file mode 100644 index 0000000000..d69804f25b --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "input", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-sw4-frame8/construction/promo/build_promotion.py", + "usage": "input", + "git_blob": "f1daad34c22efdd97a11b1e16384962b8af1d704", + "sha256": "9c9e2001b8d68bbe934d136026276fe97bd9bf6f94d4d78441fc28e14aca4daf" + }, + { + "path": "research/gauge44-slots/independent/audit_local.py", + "usage": "input", + "git_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "sha256": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd" + } + ] +} diff --git a/research/complex-frame-plane-rail-seedca04cc/TASK.json b/research/complex-frame-plane-rail-seedca04cc/TASK.json new file mode 100644 index 0000000000..08f89e1556 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "refined", + "actual_scope": "For the exact selected PR1094 local word, enumerate each coordinate 2-plane in F2^9 at every helper-helper A/B addition; propagate it by least common-frame closure while preserving exact target-level, centre-frame, target, and dirty-helper endpoints; price every induced rank climb and test the exact fixed-template ceiling.", + "scope_change_reason": "The catalogue card is broad across decoder identities. This run isolates a distinct temporal frame-schedule mechanism on the selected native word, changing frame timing while holding the scalar program, helpers, start frames, and all required interfaces fixed.", + "bottleneck_link": "Each propagated frame changes the exact local child-rank histogram that enters the paid recursive moment and its fixed-template ceiling. A beneficial schedule could lower the charged moment without changing the scalar supplier; a boundary conflict or unchanged profile cannot.", + "budget_minutes": 60, + "stop_rule": "Exhaust the 36 coordinate 2-planes and all 2,525 helper-helper A/B addition seed gates in the pinned word, discarding closures that alter any exact internal or terminal endpoint; stop after exact ceiling intervals are computed for every surviving distinct profile.", + "outcome": "negative-result", + "evidence": "Exact finite search covered 90,900 plane/gate pairs: 569 no-ops, 89,737 endpoint or exact-interface conflicts, and 594 valid schedules spanning 13 rank profiles. Exact interval ceilings show the best surviving profile equals the selected baseline bracket [1690054109/10^12, 169005411/10^11]; its lower endpoint exceeds every other profile's upper endpoint, and no profile clears the task's 5% gate. The serialized best-profile word passes the pinned independent exact native audit. No new kappa or supplier admission is claimed.", + "author": "OpenAI Codex autonomous research agent", + "ai_assistance": "OpenAI Codex autonomously selected the task, designed and implemented the finite enumerator, generated the candidate and proof artifacts, and ran the declared exact and native checks. Repository scripts and pinned predecessor code are identified in SOURCES.json. No external human contribution is claimed for this package.", + "open_questions": [ + { + "question": "Can a non-coordinate 2-dimensional subspace of F2^9, injected at one helper-helper gate in the same pinned word, produce a strictly higher exact ceiling while respecting the same interfaces?", + "why_it_matters": "The 36 coordinate planes cover only a small subset of the Grassmannian; a different plane orientation may encounter fewer fixed-frame conflicts or induce a different rank profile.", + "first_step": "Compute the stabilizer of the pinned gate supports and exact interface frames, quotient the 43,435 two-dimensional subspaces of F2^9 by that action, then screen one representative per orbit before exact pricing.", + "blocked_by": "This cycle did not enumerate non-coordinate planes; the current finite negative result is limited to coordinate planes and single-gate injection." + } + ] +} diff --git a/research/complex-frame-plane-rail-seedca04cc/TASK.md b/research/complex-frame-plane-rail-seedca04cc/TASK.md new file mode 100644 index 0000000000..9cbc6e6ccb --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/TASK.md @@ -0,0 +1,82 @@ +# Cycle 15 task card: two-coordinate frame rail + +- Seed: `ca04ccbf3c8c214a13d9c2452e780d32` (OS-random selector seed) +- Track: `complex-mechanisms` +- Catalogue task: `complex-rank-shape-decoder` +- Priority revision: 3 +- Catalogue SHA-256: `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075` +- Base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea` +- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` + +## Question and changed hypothesis + +In the selected PR1094 native local word, can one canonical two-coordinate plane +`span(e_i,e_j)` be introduced at a helper-to-helper addition and propagated by +inclusion-minimal common-frame closure through later additions, keeping every +scalar gate, start frame, exact A/B target-level and centre-frame boundary, +required target endpoint, and dirty-helper endpoint fixed? Does any such +schedule move enough paid rank mass into larger children to raise the exact +fixed-template packing ceiling by at least 5%? + +The change is a global temporal frame schedule for one shared plane. It is not +an added scalar operation or a new endpoint/helper inventory. Every induced +frame climb is charged at its exact rank; candidates changing the exact A/B +boundary, target endpoint, or helper endpoint are rejected. + +## Bounded domain and stopping rule + +Search the 36 coordinate two-planes of the pinned nine-dimensional F2 frame +space and every A/B addition in the selected word whose two operands are +helpers. For each (plane, seed gate), propagate the plane forward through the +word by the least frame enlargement that preserves monotonicity. Reject any +schedule that changes one of the exact target-level or centre-frame barriers +at the A/B boundary, or any final target/helper endpoint. Compute the complete +exact rank histogram and fixed-template moment ceiling for every surviving +schedule. Stop after this finite domain is covered; report the best profile and +ceiling, including the exact rejection counts by interface and endpoint. + +The optimistic screen is favorable: the baseline selected ceiling is +`0.001690054109089`; moving 10% of local rank mass to rank 9 reaches only +`1.04318x`, so at least about 12% must be redistributed to cross the card's +5% threshold. A single local gate change is not a sufficient experiment. + +## Source and overlap + +Pinned word: member +`candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz` of +`research/community-frontier1094-audit/selected-replay.tar.gz` (archive SHA-256 +`f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6`, member +SHA-256 `49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289`). +The current selected local profile is `{1:2412, 2:418, 3:432, 4:142, 5:82, +8:8}`. The base word and selected record remain untouched. + +Relevant predecessors: selected complex provider PR #1094; exact fixed late +block optimum PR #1429 / package `complex-block-rank-optimum`; frame coalescence +PR #699 and SW4 eight-B-frame package `complex-sw4-frame8`; cross-block fixed +late-interface floor PR #1517. Adjacent open PR #1186 supplies an exact frame +solver and delivery-rewrite search for an older PR #1148 joint-entrance k8 word; +this task instead exhausts forced coordinate-plane closures on the selected +PR1094 word, preserving its exact interfaces. The refreshed overlap search at +2026-10-14 16:29:05 UTC covered all 438 open PRs and 619 discussions. Its five +text matches were this run's two claim comments, one plane-port discussion +thread, and two local background documents; no PR title/body matched the query. +Manual review found open PR #1825 (paired plane-port decoder on selected labels) +and PR #1900 (five plane queries for the P111 bit decoder) change the coverage +contract/decoder, while PR #1186 optimizes frames on an older word. These differ +from this fixed-coverage, fixed-word temporal frame schedule. Nearby active +scopes #18924220 (Cartesian source-destination grid), PR #1909 (tetrad-local +masked decoder), and Discussion #1622 (overcomplete ten-term decoder) also +concern different objects and methods. Discussion claim #18924772 and PRs +#1825/#1900 study two-unpaid-coordinate plane-port decoders; this run keeps +coverage and helper inventory unchanged and varies only internal frame timing. + +Expected artifact: exact candidate enumerator/closure verifier, replay command, +profile/ceiling receipt, endpoint-conflict and no-op controls, predecessor +attribution, and explicit absence of a new-kappa claim unless full integration +is separately established. + +Correction: the first posted claim used the older PR699 SW4 word and was +released at Discussion comment #18926956 before packaging. This revised card +uses the exact selected PR1094 source archive and word member above. + +Claim expiry: 2026-10-14 17:18:00 UTC. diff --git a/research/complex-frame-plane-rail-seedca04cc/VERIFY.json b/research/complex-frame-plane-rail-seedca04cc/VERIFY.json new file mode 100644 index 0000000000..cc1a6a1403 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/VERIFY.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-sw4-frame8/construction/promo/build_promotion.py", + "research/gauge44-slots/independent/audit_local.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Replays the exact 90,900-pair search, compares all exact profile/ceiling evidence and bounded counts, audits the committed candidate against the pinned native checker, and confirms a paid-profile corruption is rejected." + } + ] +} diff --git a/research/complex-frame-plane-rail-seedca04cc/search.py b/research/complex-frame-plane-rail-seedca04cc/search.py new file mode 100644 index 0000000000..91f8a2a342 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/search.py @@ -0,0 +1,423 @@ +#!/usr/bin/env python3 +"""Exact finite search for a two-coordinate frame rail in the pinned SW4 word.""" +from __future__ import annotations + +import argparse +import bisect +import gzip +import hashlib +import heapq +import importlib.util +import json +import math +import tarfile +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PKG = Path(__file__).resolve().parent +ARCHIVE_REL = Path("research/community-frontier1094-audit/selected-replay.tar.gz") +ARCHIVE_MEMBER = "candidate/strict/global/base/providers/gauge44/FULL-WORD.json.gz" +PROMOTION = ROOT / "research/complex-sw4-frame8/construction/promo/build_promotion.py" +CEILING = ROOT / "research/complex-local-word-ceiling/ceiling.py" + + +def load_module(name: str, path: Path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + assert spec and spec.loader + spec.loader.exec_module(module) + return module + + +bp = load_module("imb_frame_promotion", PROMOTION) +C = load_module("imb_complex_ceiling", CEILING) + + +def regs(e): + return [e[1]] + ([e[2]] if e[0] == "add" else []) + + +def full_frame(word, r): + v = word["report"]["v"] + if v <= r < 2 * v: + port = word["ports"][r - v] + return bp.span([x for x in range(1, 512) if (x & port).bit_count() % 2 == 0]) + final = {int(k): bp.span(vs) for k, vs in word.get("helper_final", {}).items()} + return final.get(r, bp.span([1 << i for i in range(9)])) + + +def events_for(word): + """Replay the exact climb order used by build_promotion.chain_profile.""" + v, R = word["report"]["v"], word["report"]["R"] + n = 2 * v + R + cur = [() for _ in range(n)] + for i, p in enumerate(word["ports"]): + cur[i] = bp.span([p]) + for r, f in word.get("start_extra", {}).items(): + cur[int(r)] = bp.span(f) + events = [] + + def add_event(location, participants, frame, is_final=False, is_barrier=False): + F = bp.span(frame) + assert len(set(participants)) == len(participants), ("self-add unsupported", location) + before = tuple(cur[r] for r in participants) + ranks = tuple(len(F) - len(S) for S in before) + assert all(x >= 0 for x in ranks), ("nonmonotone base", location) + events.append({"location": location, "regs": tuple(participants), "frame": F, + "before": before, "ranks": ranks, "final": is_final, + "barrier": is_barrier}) + for r in participants: + cur[r] = F + + for section in ("A", "B"): + for i, e in enumerate(word[section]): + add_event((section, i), regs(e), e[-1]) + if section == "A": + # The selected native contract fixes these exact interfaces at the + # A/B boundary; they are not merely final-endpoint inclusions. + levels = {int(t): bp.span(U) for t, U in word.get("target_levels", {}).items()} + for t in range(v): + add_event(("target_level", t), [v + t], levels.get(t, ()), is_barrier=True) + for i, (r, U) in enumerate(zip(word["centers"], word["center_frames"])): + add_event(("center_frame", i), [r], U, is_barrier=True) + for j, (i, frame) in enumerate(word.get("early_cleanup", [])): + add_event(("early_cleanup", j), regs(word["cleanup"][i]), frame) + for r in range(n): + add_event(("final", r), [r], full_frame(word, r), True) + chain = Counter(rank for ev in events for rank in ev["ranks"] if rank) + profile = Counter({int(k): v for k, v in word["report"]["local_profile"].items()}) + fixed = profile - chain + assert not (chain - profile), ("climb profile exceeds report", dict(chain), dict(profile)) + assert dict(fixed) == {8: 8}, ("unexpected non-chain profile component", dict(fixed)) + return events, profile, chain, fixed + + +def plane_candidates(): + for i in range(9): + for j in range(i + 1, 9): + yield (1 << i, 1 << j) + + +def aug_span(F, P): + return bp.span(list(F) + list(P)) + + +def candidate_seeds(word, events): + helpers = 2 * word["report"]["v"] + out = [] + for idx, ev in enumerate(events): + sec, _ = ev["location"] + if sec in ("A", "B") and len(ev["regs"]) == 2 and all(r >= helpers for r in ev["regs"]): + out.append(idx) + return out + + +def inspect_plane(word, events, base_profile, P, seeds, target_a, exact_costs): + """Enumerate seed gates for P, returning exact threshold counts and the best float screen.""" + info = [] + for ev in events: + F = ev["frame"] + Fa = aug_span(F, P) + info.append((len(Fa), len(Fa) == len(F), tuple(len(aug_span(S, P)) for S in ev["before"]))) + + by_reg = [[] for _ in range(2 * word["report"]["v"] + word["report"]["R"])] + for idx, ev in enumerate(events): + for r in ev["regs"]: + by_reg[r].append(idx) + + baseline = [0] * 10 + for r, count in base_profile.items(): + assert 1 <= r <= 9 + baseline[r] = count + base_profile_tuple = tuple(baseline) + best = None + tested = noop = endpoint_reject = interface_reject = 0 + qualify = reject_below = ambiguous = 0 + first_endpoint_control = None + seen_profiles = set() + + for seed in seeds: + if info[seed][1]: + noop += 1 + continue + tested += 1 + counts = baseline.copy() + active = set() + heap = [] + + def change_profile(ev_idx, active_before, new_frame_dim): + ev = events[ev_idx] + dims, ranks = ev["before"], ev["ranks"] + aug_dims = info[ev_idx][2] + for pos, r in enumerate(ev["regs"]): + old = ranks[pos] + if old: + counts[old] -= 1 + prior = aug_dims[pos] if r in active_before else len(dims[pos]) + nr = new_frame_dim - prior + if nr < 0: + raise AssertionError(("negative climb", P, seed, ev_idx, r, nr)) + if nr: + counts[nr] += 1 + + # The seed introduces P into the common frame and both helper registers. + ev = events[seed] + change_profile(seed, set(), info[seed][0]) + if info[seed][1]: + raise AssertionError("no-op seed was not filtered") + active.update(ev["regs"]) + for r in ev["regs"]: + q = bisect.bisect_right(by_reg[r], seed) + if q < len(by_reg[r]): + heapq.heappush(heap, (by_reg[r][q], r)) + + valid = True + while heap: + idx = heap[0][0] + touched_active = set() + while heap and heap[0][0] == idx: + _, r = heapq.heappop(heap) + if r in active: + touched_active.add(r) + if not touched_active: + continue + ev = events[idx] + info_idx = info[idx] + touched = set(ev["regs"]) + if (ev["final"] or ev["barrier"]) and not info_idx[1]: + valid = False + endpoint_reject += 1 + if ev["barrier"]: + interface_reject += 1 + if first_endpoint_control is None: + first_endpoint_control = {"seed_event": seed, "plane": list(P), + "endpoint_event": idx, "registers": sorted(touched_active), + "endpoint_frame": list(ev["frame"]), + "boundary_kind": ev["location"][0]} + break + change_profile(idx, touched_active, info_idx[0]) + if info_idx[1]: + active.difference_update(touched) + else: + active.update(touched) + for r in touched: + if r in active: + q = bisect.bisect_right(by_reg[r], idx) + if q < len(by_reg[r]): + heapq.heappush(heap, (by_reg[r][q], r)) + if not valid: + continue + if active: + raise AssertionError(("active plane survived endpoints", seed, P, active)) + mass = sum(r * counts[r] for r in range(1, 10)) + base_mass = sum(r * base_profile[r] for r in base_profile) + assert mass == base_mass, ("rank mass changed despite fixed endpoints", mass, base_mass, seed, P) + pt = tuple(counts) + seen_profiles.add(pt) + lower_num, upper_num, threshold_num = exact_costs(pt) + if lower_num > threshold_num: + reject_below += 1 + elif upper_num < threshold_num: + qualify += 1 + else: + ambiguous += 1 + # Fast monotone bisection ranks candidates; exact intervals decide the gate above. + score = float_ceiling(counts) + if best is None or score > best[0]: + best = (score, seed, P, pt) + + return {"tested": tested, "no_op": noop, "endpoint_reject": endpoint_reject, + "interface_reject": interface_reject, + "below_5pct": reject_below, "above_5pct": qualify, "ambiguous": ambiguous, + "unique_profiles": len(seen_profiles), "profiles": [list(x) for x in sorted(seen_profiles)], + "best": best, + "first_endpoint_control": first_endpoint_control} + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--word", type=Path, help="optional exact extracted selected word; archive is the default") + ap.add_argument("--archive", type=Path, default=ROOT / ARCHIVE_REL) + ap.add_argument("--out", type=Path, default=PKG / "SEARCH.json") + ap.add_argument("--candidate-word", type=Path, default=PKG / "BEST-WORD.json.gz") + a = ap.parse_args() + archive_raw = a.archive.read_bytes() + assert hashlib.sha256(archive_raw).hexdigest() == "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + if a.word is None: + import io + with tarfile.open(fileobj=io.BytesIO(archive_raw), mode="r:gz") as tf: + raw = tf.extractfile(ARCHIVE_MEMBER).read() + else: + raw = a.word.read_bytes() + word = json.loads(gzip.decompress(raw)) + assert hashlib.sha256(raw).hexdigest() == "49596aa4ed4fd36cd4582fd0e8ddeb09fd80370a7d8aea1ede52a135b536d289" + events, profile, oldchain, fixed_profile = events_for(word) + seeds = candidate_seeds(word, events) + assert len(seeds) > 0 + base_model = C.model(profile, 73, 896, 9, 64) + base_bracket = C.ceiling(profile, 73, 896, 9, 64, grid=Q(1, 10**12)) + target_a = base_bracket[1] * Q(21, 20) + scale = 1 << C.PREC + cost_l, cost_u = {}, {} + for r in range(1, 10): + lo, hi = C.child_cost(r, 73, target_a) + cost_l[r], cost_u[r] = int(lo * scale), int(hi * scale) + lo51, hi51 = C.child_cost(base_model["R"], 73, target_a) + cost_l[base_model["R"]], cost_u[base_model["R"]] = int(lo51 * scale), int(hi51 * scale) + idle = base_model["idle_mass"] + w = base_model["w"] + + def exact_costs(count_tuple): + local_lo = sum(Q(count_tuple[r]) * cost_l[r] for r in range(1, 10)) + local_hi = sum(Q(count_tuple[r]) * cost_u[r] for r in range(1, 10)) + local_lo += idle / base_model["R"] * cost_l[base_model["R"]] + local_hi += idle / base_model["R"] * cost_u[base_model["R"]] + threshold = w * scale + return local_lo, local_hi, threshold + + global_best = None + totals = Counter() + plane_rows = [] + all_profiles = set() + for P in plane_candidates(): + print("SEARCH plane", list(P), "candidate seeds", len(seeds), flush=True) + row = inspect_plane(word, events, profile, P, seeds, target_a, exact_costs) + plane_rows.append({k: v for k, v in row.items() if k != "best"}) + all_profiles.update(tuple(x) for x in row["profiles"]) + for k in ("tested", "no_op", "endpoint_reject", "interface_reject", "below_5pct", "above_5pct", "ambiguous"): + totals[k] += row[k] + if row["best"] and (global_best is None or row["best"][0] > global_best[0]): + global_best = row["best"] + print("DONE plane", list(P), "tested", row["tested"], "endpoint rejects", row["endpoint_reject"], + "best a", row["best"][0] if row["best"] else None, flush=True) + + assert global_best is not None + approx, seed, P, pt = global_best + best_profile = {r: pt[r] for r in range(1, 10) if pt[r]} + best_bracket = C.ceiling(best_profile, 73, 896, 9, 64, grid=Q(1, 10**12)) + threshold_check = C.relax(best_profile, 73, 896, 9, 64, target_a) + best_events = events + newword = json.loads(json.dumps(word)) + plane = tuple(P) + active = set() + # Reconstruct the globally best minimal closure to serialize it. + for idx in range(seed, len(events)): + ev = events[idx] + changed = idx == seed or bool(active.intersection(ev["regs"])) + if not changed: + continue + oldF = ev["frame"] + newF = aug_span(oldF, plane) + if ev["location"][0] == "final": + assert len(newF) == len(oldF), "best closure changes final endpoint" + elif ev["barrier"]: + assert len(newF) == len(oldF), "best closure changes exact A/B interface" + elif newF != oldF: + sec, pos = ev["location"] + if sec in ("A", "B"): + newword[sec][pos][-1] = list(newF) + elif sec == "early_cleanup": + newword["early_cleanup"][pos][1] = list(newF) + contains = len(newF) == len(oldF) + if contains: + active.difference_update(ev["regs"]) + else: + active.update(ev["regs"]) + assert not active + newchain = bp.chain_profile(newword) + assert Counter(newchain) + Counter(fixed_profile) == Counter(best_profile), ( + newchain, fixed_profile, best_profile) + merged = Counter({int(k): v for k, v in word["report"]["local_profile"].items()}) + merged.subtract(oldchain) + merged.update(newchain) + newword["report"]["local_profile"] = {str(r): n for r, n in sorted(merged.items()) if n} + newword["report"]["local_rank_mass"] = sum(r * n for r, n in merged.items()) + assert merged == Counter(best_profile), (dict(merged), best_profile) + outbytes = json.dumps(newword, sort_keys=True, separators=(",", ":")).encode() + a.candidate_word.parent.mkdir(parents=True, exist_ok=True) + compressed_word = gzip.compress(outbytes, mtime=0) + a.candidate_word.write_bytes(compressed_word) + + # Exact ceilings for every distinct surviving profile make the reported + # finite-domain maximum independent of the float ranking shortcut. + profile_ceilings = [] + for values in sorted(all_profiles): + prof = {r: values[r] for r in range(1, 10) if values[r]} + bracket = C.ceiling(prof, 73, 896, 9, 64, grid=Q(1, 10**12)) + profile_ceilings.append({"profile": {str(r): n for r, n in prof.items()}, + "bracket": [str(x) for x in bracket]}) + profile_ceilings.sort(key=lambda row: Q(row["bracket"][0]), reverse=True) + assert profile_ceilings[0]["profile"] == {str(r): n for r, n in best_profile.items()}, ( + "exact ceiling ranking disagrees with float candidate ranking", profile_ceilings[0], best_profile) + best_lower = Q(profile_ceilings[0]["bracket"][0]) + max_other_upper = max((Q(row["bracket"][1]) for row in profile_ceilings[1:]), default=Q(0)) + assert best_lower > max_other_upper, ("distinct profile ceiling intervals do not separate", + profile_ceilings[0], max_other_upper) + + result = { + "status": "PASS_TWO_PLANE_FRAME_RAIL_SEARCH", + "seed": "ca04ccbf3c8c214a13d9c2452e780d32", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_source_archive_sha256": hashlib.sha256(archive_raw).hexdigest(), + "word_member": ARCHIVE_MEMBER, + "word_sha256": hashlib.sha256(raw).hexdigest(), + "search_domain": {"planes": 36, "helper_helper_seed_gates": len(seeds), + "seed_plane_pairs": 36 * len(seeds)}, + "totals": dict(totals), + "best": {"approx_a": approx, "seed_event": seed, "plane": list(P), + "profile": {str(r): n for r, n in best_profile.items()}, + "rank_mass": sum(r * n for r, n in best_profile.items()), + "ceiling_bracket": [str(x) for x in best_bracket], + "target_a_5pct": str(target_a), + "target_relax_interval": [str(x) for x in threshold_check], + "profile_sha256": hashlib.sha256(json.dumps(best_profile, sort_keys=True).encode()).hexdigest(), + "word_output_sha256": hashlib.sha256(outbytes).hexdigest()}, + "base_profile": {str(r): n for r, n in sorted(profile.items())}, + "base_ceiling_bracket": [str(x) for x in base_bracket], + "distinct_valid_profiles": len(profile_ceilings), + "exact_profile_ceilings": profile_ceilings, + "plane_rows": plane_rows, + "exact_best_separation": {"best_profile": profile_ceilings[0]["profile"], + "best_lower": str(best_lower), + "max_other_upper": str(max_other_upper), + "strictly_separated": True}, + "negative_control": {"kind": "exact internal interface barrier conflict", + "example": plane_rows[0]["first_endpoint_control"], + "rejected_seed_plane_pairs": totals["endpoint_reject"], + "interface_rejections": totals["interface_reject"]}, + "construction_effect": {"scalar_program_unchanged": True, + "start_frames_unchanged": True, + "A_B_target_levels_and_centres_exact": True, + "terminal_endpoints_unchanged": True, + "additional_arrays": 0, + "additional_scalar_gates": 0, + "all_induced_rank_climbs_charged": True}, + } + a.out.parent.mkdir(parents=True, exist_ok=True) + a.out.write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({k: result[k] for k in ("status", "search_domain", "totals", "best")}, indent=2)) + + +def float_ceiling(counts): + """Fast ranking only; exact threshold and final ceiling use the pinned interval engine.""" + m, families, stages, centre, R = 73, 896, 9, 64, 51 + w = families / stages + mass = sum(r * counts[r] for r in range(1, 10)) + idle = (m - 1) * w + centre - mass + lo, hi = 0.0, 0.05 + for _ in range(35): + a = (lo + hi) / 2 + moment = sum(counts[r] * (r / m) ** (1 - a) for r in range(1, 10)) + moment += (idle / R) * (R / m) ** (1 - a) + if moment / w < 1: + lo = a + else: + hi = a + return lo + + +if __name__ == "__main__": + main() diff --git a/research/complex-frame-plane-rail-seedca04cc/verify.py b/research/complex-frame-plane-rail-seedca04cc/verify.py new file mode 100644 index 0000000000..283990b067 --- /dev/null +++ b/research/complex-frame-plane-rail-seedca04cc/verify.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python3 +"""Replay the finite frame-rail search and audit its serialized best word.""" +from __future__ import annotations + +import gzip +import hashlib +import json +import subprocess +import sys +import tempfile +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] + + +def require(condition: bool, message: str) -> None: + if not condition: + raise RuntimeError(message) + + +def load_json(path: Path): + return json.loads(path.read_text(encoding="utf-8")) + + +def run(argv: list[str], *, timeout: int = 600, expect_success: bool = True): + result = subprocess.run(argv, cwd=ROOT, capture_output=True, text=True, timeout=timeout) + if expect_success and result.returncode != 0: + raise RuntimeError(f"command failed ({result.returncode}): {' '.join(argv)}\n{result.stdout}\n{result.stderr}") + if not expect_success and result.returncode == 0: + raise RuntimeError(f"negative control unexpectedly passed: {' '.join(argv)}") + return result + + +def normalized_search(value): + """Drop only float ranking and the tie-selected closure serialization.""" + value = json.loads(json.dumps(value)) + best = value["best"] + for key in ("approx_a", "seed_event", "plane", "profile_sha256", "word_output_sha256"): + best.pop(key, None) + return value + + +def main() -> None: + expected = load_json(PACKAGE / "SEARCH.json") + receipt = load_json(PACKAGE / "NATIVE-AUDIT.json") + require(expected["status"] == "PASS_TWO_PLANE_FRAME_RAIL_SEARCH", "search result status") + require(expected["search_domain"] == {"planes": 36, "helper_helper_seed_gates": 2525, + "seed_plane_pairs": 90900}, "search domain drift") + require(expected["totals"] == {"tested": 90331, "no_op": 569, "endpoint_reject": 89737, + "interface_reject": 56830, "below_5pct": 594, + "above_5pct": 0, "ambiguous": 0}, "search totals drift") + require(expected["distinct_valid_profiles"] == 13, "distinct profile count") + require(expected["exact_best_separation"]["strictly_separated"], "exact profile ceilings do not separate") + control = expected["negative_control"]["example"] + require(control["boundary_kind"] == "center_frame", "expected internal centre-frame negative control") + require(not set(control["plane"]).issubset(set(control["endpoint_frame"])), + "negative-control plane unexpectedly fits the exact centre frame") + require(expected["negative_control"]["interface_rejections"] > 0, "no exact interface conflicts exercised") + require(expected["best"]["profile"] == expected["exact_best_separation"]["best_profile"], + "best profile differs from exact ceiling winner") + require(expected["best"]["ceiling_bracket"] == expected["base_ceiling_bracket"], + "scoped result no longer ties the pinned baseline ceiling") + + with tempfile.TemporaryDirectory(prefix="imb-frame-rail-") as directory: + temporary = Path(directory) + generated_search = temporary / "SEARCH.json" + generated_word = temporary / "BEST-WORD.json.gz" + run([sys.executable, "-B", str(PACKAGE / "search.py"), "--out", str(generated_search), + "--candidate-word", str(generated_word)]) + regenerated = load_json(generated_search) + require(normalized_search(regenerated) == normalized_search(expected), + "replayed finite search differs from committed exact evidence") + generated_word_data = json.loads(gzip.decompress(generated_word.read_bytes())) + require(generated_word_data["report"]["local_profile"] == expected["best"]["profile"], + "replayed best word has a different paid profile") + + # Independently check the committed candidate. Then corrupt only its + # claimed paid histogram and require the same auditor to reject it. + word = PACKAGE / "BEST-WORD.json.gz" + audit_out = temporary / "NATIVE-AUDIT.json" + audit_script = ROOT / "research/gauge44-slots/independent/audit_local.py" + run([sys.executable, "-B", str(audit_script), "--word", str(word), "--output", str(audit_out)], timeout=120) + actual_audit = load_json(audit_out) + stable_actual = {k: v for k, v in actual_audit.items() if k != "elapsed_seconds"} + stable_expected = {k: v for k, v in receipt.items() if k != "elapsed_seconds"} + require(stable_actual == stable_expected, "native audit receipt differs") + require(actual_audit["local_profile"] == expected["best"]["profile"], + "native audited paid profile differs from exact search winner") + compressed = word.read_bytes() + content = gzip.decompress(compressed) + require(hashlib.sha256(content).hexdigest() == receipt["content_sha256"], "candidate content pin mismatch") + + bad = json.loads(content) + bad["report"]["local_profile"]["1"] += 1 + bad_word = temporary / "BAD-PAID-PROFILE.json.gz" + bad_word.write_bytes(gzip.compress(json.dumps(bad, sort_keys=True, separators=(",", ":")).encode(), mtime=0)) + rejected = run([sys.executable, "-B", str(audit_script), "--word", str(bad_word), + "--output", str(temporary / "BAD-AUDIT.json")], timeout=120, expect_success=False) + require("paid profile mismatch" in rejected.stderr, "negative control failed for an unrelated reason") + + print("PASS_FRAME_RAIL_FINITE_SEARCH_NATIVE_AUDIT_AND_NEGATIVE_CONTROL") + + +if __name__ == "__main__": + main()