From e3ef128540fcce9a325359e55b35ccc3d1587ea9 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Sat, 17 Oct 2026 16:47:39 -0500 Subject: [PATCH] research: isolate orthogonal remainder overlays --- .../README.md | 133 + .../RESULT.json | 2915 +++++++++++++++++ .../SOURCES.json | 108 + .../TASK.json | 60 + .../VERIFY.json | 35 + .../verify.py | 355 ++ 6 files changed, 3606 insertions(+) create mode 100644 research/pr3190-distinct-axis-basis-isolation/README.md create mode 100644 research/pr3190-distinct-axis-basis-isolation/RESULT.json create mode 100644 research/pr3190-distinct-axis-basis-isolation/SOURCES.json create mode 100644 research/pr3190-distinct-axis-basis-isolation/TASK.json create mode 100644 research/pr3190-distinct-axis-basis-isolation/VERIFY.json create mode 100644 research/pr3190-distinct-axis-basis-isolation/verify.py diff --git a/research/pr3190-distinct-axis-basis-isolation/README.md b/research/pr3190-distinct-axis-basis-isolation/README.md new file mode 100644 index 0000000000..43235cbda5 --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/README.md @@ -0,0 +1,133 @@ +# Isolation for orthogonal simultaneous remainder transfers + +**Scoped negative result; no new κ and no selected-result change.** This package +closes one part of the simultaneous-transfer question raised by open PR +[#3296](https://github.com/CrocSwap/integer-mult-bounds/pull/3296). It proves a +conditional operator obstruction for any number of pairwise-orthogonal moved +axes, and independently reproduces the exact singleton facts used by that +argument. PR [#3311](https://github.com/CrocSwap/integer-mult-bounds/pull/3311) +independently replays a different, port-zero literal witness; this package +covers the all-port singleton domain and the orthogonal-axis implication. + +## Exact scope and result + +The source universe is fixed at main commit +`463113d675af7410ac91d53a4fed51ec6494eb9a`: the authenticated 2,717,280-row +PR3148 fill, the 112 port recipes, the fixed chronology, allocation and template +inputs listed in [SOURCES.json](SOURCES.json), owner replica zero, cover identity, +and PR3187's exact eight-stream Gaussian-integer replay. The proposed per-axis +rule is transcribed in `declared_rule` in [verify.py](verify.py) from PR #3190 at +head `5e4a3235169edddd033889da4e9f47635ff50c3e`: a moved axis belongs to its +donor remainder, donor and receiver differ, and the axis is orthogonal to the +receiver's current remainder axes, every stage entry/exit X/Y translation, the +terminal Y translation, and the donor and receiver terminal translations. +The resulting child ranks must not exceed 51 and each child's axes must remain +orthonormal. + +The enumerated domain deliberately relaxes PR #3190's construction restrictions: +it admits any receiver with a nonempty full axis list, including a hosted +receiver, and does not forbid a child from being both donor and receiver in a +bundle. Thus it is a superset for the commuting-rule audit, not an assertion +that every enumerated overlay satisfies the native controller or hosting +contract. Excluding operator-preserving overlays in this superset is stronger +than excluding only the narrower PR #3190 move class. + +Across all 112 ports, the verifier enumerates 9,384 candidate single-axis +transfers from a hosted child with a nonempty remainder to another child whose +full axis list is nonempty (the receiver's residual may be empty). Of those, +5,575 fail the declared rule. The other 3,809 pass the +rule and final rank/frame checks. At each such transfer's own moved-axis +Fourier character, the unchanged baseline is the exact scalar matrix and the +single transfer changes the exact 8-by-8 Gaussian-integer matrix. The stored +[RESULT.json](RESULT.json) contains every per-port count and the pair-control's +baseline, singleton and bundle matrices at both moved-axis characters, including +the exact changed entries. This is finite source-bound evidence for those +singleton premises. + +## Isolation lemma + +Fix any one of the 112 ports and its source-bound schedule. Let +`T_i = (d_i, r_i, v_i)` be a nonempty finite collection of distinct +single-axis transfers from the enumerated singleton domain. Suppose their moved +axes are pairwise orthogonal over `F_2`, each move uses its donor axis at most +once, and the combined final assignment satisfies the rank and within-child +orthonormality checks. For each `i`, let `M_i(v_i)` be the exact replay after +only `T_i`, evaluated at character `v_i`; let `M_B(v_i)` be the replay after +the whole bundle `B`, at the same character. + +Then, for every `i`, + +```text +M_B(v_i) = M_i(v_i) != M_empty(v_i). +``` + +For the equality, inspect an idle-cover-sweep phase in the source replay. A +residual axis `w` contributes `dot(character, w)` to its child's phase exponent; +this rule is implemented in PR3187's unchanged +[algebra.py](../rank7-idle-star-stream-obstruction/algebra.py). Set the +character to `v_i`. The selected move changes the residual membership of +`v_i`, with `dot(v_i, v_i) = 1`. Every other moved axis `v_j` contributes zero +because `dot(v_i, v_j) = 0`. Thus all other transfers leave every idle-sweep +phase unchanged at this character. Hosted rows, translations, bridges, local +sweeps, terminal events and chronology are fixed, so the full matrix replay is +exactly the singleton replay. The singleton census proves the inequality for +each possible `T_i`; hence the bundle cannot preserve the operator. + +The orthogonality premise also keeps each component's receiver-axis check true +while the bundle is applied: other transferred axes added to or removed from a +receiver have zero dot product with it. Distinct donor axes remain available, +and only the combined rank/frame check adds a bundle-level condition. + +This argument quantifies over arbitrary finite bundle size within the stated +source and legality conditions; it does not enumerate bundles. The verifier +also finds a legal port-zero pair, `4→0` with axis `2^32` and `14→0` with axis +`2^72`, and replays the bundle. At each moved-axis character, the bundle matrix +equals the corresponding singleton matrix. Both baselines are `i I_8`; the +singletons differ from them in 2 and 5 matrix entries respectively, so this pair +also supplies an explicit joint-change example. RESULT.json records the exact +baseline, singleton and bundle matrices. The proof, rather than that fixture, +establishes the all-finite-bundle implication. + +## Open next questions + +This result does **not** exclude a simultaneous bundle containing nonorthogonal +moved axes (including repeated copies of the same vector), an overlay whose +components are not individually in the enumerated singleton domain, another +owner replica, a changed host schedule, or a repaired/rescheduled exchange. It +does not prove that all of PR #3190's proposed gains fail under every repair, and +it does not establish any general κ bound. Those are separate questions. + +The next concrete step is to identify the smallest legal simultaneous +hosted-remainder overlay in this fixed schedule with two nonorthogonal moved +axes, then test for a character that isolates it or a written obstruction that +does not require orthogonality. Other replicas and schedule repairs remain +separate scope expansions. + +## Reproduction and provenance + +The verifier imports PR3187's authenticated source loader and exact event +semantics unchanged. Its new work reconstructs the owner-zero rows for all 112 +ports, transcribes the declared rule, enumerates every scoped singleton, and +proves the character-isolation implication above. This is a new binding and +algebraic implication, **not** an independent reimplementation of the physical +operator model. Inputs, Git blobs and SHA256 hashes are pinned in +[SOURCES.json](SOURCES.json); all live inputs are listed in [VERIFY.json](VERIFY.json). + +From the repository root, with Python 3.12: + +```sh +python3.12 scripts/research_package.py --package research/pr3190-distinct-axis-basis-isolation +python3 scripts/research_package.py --package research/pr3190-distinct-axis-basis-isolation --check-only +``` + +`verify.py --write` regenerates RESULT.json after a deliberate source change; +ordinary verification compares its freshly computed result byte-semantically +to the committed receipt. The registered replay passed with Python 3.12.15; a +direct replay also passed with Python 3.14.8. The verifier uses only the Python +standard library. + +The exact replay model and source loader come from Nick Petalas's PR #3187 and +retain its PR3133 notice and credits through the pinned vendor files. The +audited remainder-transfer rule is the one stated by Rohan Arun's open PR #3190 +at the head above. New proof and verifier: Cinna Davis, with substantial +OpenAI Codex assistance. No human or proof-kernel review is claimed. diff --git a/research/pr3190-distinct-axis-basis-isolation/RESULT.json b/research/pr3190-distinct-axis-basis-isolation/RESULT.json new file mode 100644 index 0000000000..4d4906ae60 --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/RESULT.json @@ -0,0 +1,2915 @@ +{ + "audited_owner_replica": 0, + "authenticated_fill_rows": 2717280, + "cover": "identity", + "fill_payload_sha256": "8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00", + "operator": "exact eight-stream Gaussian-integer replay from PR3187", + "orthogonal_pair_control": { + "axis_dot": 0, + "bundle_equals_each_singleton_at_its_character": true, + "character_comparisons": [ + { + "baseline": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "bundle": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "character": 4294967296, + "singleton": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "singleton_difference_count": 2, + "singleton_differences": [ + [ + 2, + 2, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ], + [ + 4, + 4, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ] + ] + }, + { + "baseline": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "bundle": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -1, + 1 + ], + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -1, + 1 + ], + [ + 0, + 0 + ], + [ + 1, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "character": 4722366482869645213696, + "singleton": [ + [ + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -1, + 1 + ], + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + -1, + 1 + ], + [ + 0, + 0 + ], + [ + 1, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ] + ], + "singleton_difference_count": 5, + "singleton_differences": [ + [ + 2, + 2, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ], + [ + 3, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 3, + 3, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + 5, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 5, + 3, + [ + 0, + 0 + ], + [ + 1, + -1 + ] + ] + ] + } + ], + "characters": [ + 4294967296, + 4722366482869645213696 + ], + "moves": [ + [ + 4, + 0, + 4294967296 + ], + [ + 14, + 0, + 4722366482869645213696 + ] + ], + "port": 0 + }, + "per_port": { + "0": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "1": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "10": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "100": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "101": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "102": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "103": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "104": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "105": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "106": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "107": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "108": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "109": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "11": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "110": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "111": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "12": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "13": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "14": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "15": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "16": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "17": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "18": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "19": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "2": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "20": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "21": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "22": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "23": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "24": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "25": { + "changed_at_own_character": 104, + "distinct_singleton_characters": 6, + "final_valid_singletons": 104, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 104, + "rule_rejects": 32 + }, + "26": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "27": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "28": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "29": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "3": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "30": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 4, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 52, + "rule_rejects": 84 + }, + "31": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "32": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "33": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "34": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 4, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 52, + "rule_rejects": 84 + }, + "35": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "36": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "37": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "38": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "39": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "4": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "40": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "41": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "42": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "43": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "44": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "45": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "46": { + "changed_at_own_character": 91, + "distinct_singleton_characters": 5, + "final_valid_singletons": 91, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 91, + "rule_rejects": 45 + }, + "47": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 4, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 52, + "rule_rejects": 84 + }, + "48": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "49": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "5": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "50": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "51": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "52": { + "changed_at_own_character": 78, + "distinct_singleton_characters": 4, + "final_valid_singletons": 78, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 78, + "rule_rejects": 58 + }, + "53": { + "changed_at_own_character": 39, + "distinct_singleton_characters": 3, + "final_valid_singletons": 39, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 39, + "rule_rejects": 97 + }, + "54": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "55": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "56": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "57": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "58": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "59": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "6": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "60": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "61": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "62": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "63": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "64": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "65": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "66": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "67": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "68": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "69": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "7": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "70": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "71": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "72": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "73": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "74": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "75": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "76": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "77": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "78": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "79": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "8": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "80": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "81": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "82": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "83": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "84": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 52, + "rule_rejects": 84 + }, + "85": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 136, + "rule_passes": 0, + "rule_rejects": 136 + }, + "86": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "87": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "88": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "89": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "9": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "90": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "91": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "92": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "93": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "94": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "95": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "96": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "97": { + "changed_at_own_character": 52, + "distinct_singleton_characters": 2, + "final_valid_singletons": 52, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 52, + "rule_rejects": 16 + }, + "98": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + }, + "99": { + "changed_at_own_character": 0, + "distinct_singleton_characters": 0, + "final_valid_singletons": 0, + "final_validity_rejects": 0, + "preserved_at_own_character": 0, + "raw_candidates": 68, + "rule_passes": 0, + "rule_rejects": 68 + } + }, + "ports": 112, + "positive_control": { + "axis_absent_from_donor_rejected": true, + "character": 4294967296, + "empty_overlay_equals_baseline": true, + "port": 0, + "self_transfer_rejected": true + }, + "scope_note": "The receiver domain relaxes PR3190's construction restrictions. The theorem covers only finite legal overlays whose moved axes are pairwise orthogonal and whose components lie in that enumerated singleton domain.", + "singleton_domain": "hosted remainder donor with nonempty remainder; distinct receiver with nonempty full axis list (hosted receivers admitted); PR3190 commuting rule; final rank <= 51 and within-child orthonormality", + "source_base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "status": "PASS_DISTINCT_AXIS_OVERLAY_ISOLATION", + "summary": { + "changed_at_own_character": 3809, + "distinct_singleton_characters": 181, + "final_valid_singletons": 3809, + "final_validity_rejects": 0, + "ports_with_no_rule_passes": 47, + "preserved_at_own_character": 0, + "raw_candidates": 9384, + "rule_passes": 3809, + "rule_rejects": 5575 + } +} diff --git a/research/pr3190-distinct-axis-basis-isolation/SOURCES.json b/research/pr3190-distinct-axis-basis-isolation/SOURCES.json new file mode 100644 index 0000000000..e0bbf050f7 --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/SOURCES.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/SOURCES.json", + "usage": "input", + "git_blob": "a4bf03526b6ef83b656a7c4a9fcd04315350e9c7", + "sha256": "81b9048365550a7a0c33308ad60bcee98c9bdd6a566308572d9ef57501accfb4" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/algebra.py", + "usage": "input", + "git_blob": "6a7ff3b2fd184428569e997261a4d00bbf993455", + "sha256": "ba1e12f72e8c1b0521b566bd2cb0fbf288ad2ae866cd574e3d7a4f8ee83d7554" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/source.py", + "usage": "input", + "git_blob": "76ff8121ca6c8861f2c89f24f4f8c89957b50da3", + "sha256": "277c86537127ec53b2f0b5960274925986676b26826b37655b8f174c94512ee5" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/BASE-FILL.json.gz", + "usage": "input", + "git_blob": "92b49b42b8f381d686a9fb8057e74e4b7548cd5c", + "sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/EXCHANGE.json", + "usage": "input", + "git_blob": "f323db0fd94a80f691b1606e813d0738b27058ae", + "sha256": "5063791f327d067f37478488c97ce449e5b34cfb61d6309fc6924c5e360fe839" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/PR3133-CREDITS.md", + "usage": "input", + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/PR3133-NOTICE", + "usage": "input", + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/PROVIDERS.json", + "usage": "input", + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd" + }, + { + "path": "research/rank7-idle-star-stream-obstruction/vendor/STAR-MOVES.json.gz", + "usage": "input", + "git_blob": "ef209aa4a9c2c81d983ea58146a7cbd6770eda4c", + "sha256": "ea833cc374c16c4bed4da6328a77353171944d947bed1d28085212ffad786e90" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "usage": "input", + "git_blob": "c4150cb693414c098690eae79b3aea5f47c184ff", + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + } + ] +} diff --git a/research/pr3190-distinct-axis-basis-isolation/TASK.json b/research/pr3190-distinct-axis-basis-isolation/TASK.json new file mode 100644 index 0000000000..42a0f9cc13 --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/TASK.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one exact all-size/compiler, precision, hosting or restoration implication be proved or falsified?", + "starting_points": [ + "certificates/selected-result.json", + "docs/audit.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the selected review scope and choose one exact all-size or precision implication.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write its quantified inputs and conclusion; find a missing hypothesis or construct a minimal exact adversarial instance.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "Choose one tape, precision, hosting or restoration lemma." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision" + ] + }, + "scope_status": "changed", + "actual_scope": "At each of the 112 pinned ports, owner replica 0, prove exact operator isolation for every finite legal bundle of individually admissible hosted-remainder singleton transfers whose moved axes are pairwise orthogonal; reproduce the all-port singleton census over a receiver domain relaxed to any child with a nonempty full axis list.", + "scope_change_reason": "The catalog card invites an exact hosting implication. This narrows it to the simultaneous-transfer handoff in open PR #3296 and a fixed source-bound schedule. The singleton census deliberately enlarges PR #3190 receiver eligibility; the theorem remains conditional on pairwise orthogonality and owner replica 0, and does not claim a universal all-replica or all-schedule transfer result.", + "bottleneck_link": "A precise isolation lemma extends the finite singleton obstruction to arbitrary finite bundles in a named legal class, while identifying exactly which simultaneous transfers could still affect the construction.", + "budget_minutes": 60, + "stop_rule": "Stop after authenticating the fill, reproducing every scoped singleton and proving the orthogonal-axis isolation implication. Do not infer anything for nonorthogonal bundles, other owner replicas, schedule changes, repairs, or the selected kappa.", + "outcome": "completed", + "evidence": "README.md states the quantified lemma and its exclusions; verify.py reconstructs 112 owner-zero port contexts and checks 9,384 candidate transfers, 3,809 admitted singleton replays, exact baseline controls, and a legal orthogonal two-move fixture. RESULT.json records the per-port receipt.", + "author": "Cinna Davis, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance: source investigation, proof formulation, verifier implementation and local replay.", + "open_questions": [ + { + "question": "Can a legal simultaneous hosted-remainder overlay in the same fixed schedule that contains two nonorthogonal moved axes be excluded by an exact character witness or a written argument?", + "why_it_matters": "The isolation proof handles pairwise-orthogonal moved axes. Nonorthogonal bundles are the remaining simultaneous-transfer class that could evade its character selection.", + "first_step": "Search the pinned 112-port candidate domain for the smallest jointly legal pair with dot(v,w)=1, then compute its exact eight-stream matrices at the characters v and w before attempting larger bundles.", + "blocked_by": "No obstruction for nonorthogonal bundles is proved here; changed schedules, repairs and owner replicas other than zero also remain outside this package." + } + ] +} diff --git a/research/pr3190-distinct-axis-basis-isolation/VERIFY.json b/research/pr3190-distinct-axis-basis-isolation/VERIFY.json new file mode 100644 index 0000000000..7ec92eaca7 --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/VERIFY.json @@ -0,0 +1,35 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "research/rank7-idle-star-stream-obstruction/SOURCES.json", + "research/rank7-idle-star-stream-obstruction/algebra.py", + "research/rank7-idle-star-stream-obstruction/source.py", + "research/rank7-idle-star-stream-obstruction/vendor/BASE-FILL.json.gz", + "research/rank7-idle-star-stream-obstruction/vendor/EXCHANGE.json", + "research/rank7-idle-star-stream-obstruction/vendor/PR3133-CREDITS.md", + "research/rank7-idle-star-stream-obstruction/vendor/PR3133-NOTICE", + "research/rank7-idle-star-stream-obstruction/vendor/PROVIDERS.json", + "research/rank7-idle-star-stream-obstruction/vendor/STAR-MOVES.json.gz", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Authenticate the full literal fill; reconstruct all 112 owner-zero ports; reproduce the exact 9,384-candidate singleton census and all 3,809 changed singleton matrices; check scalar baselines, failure controls and a legal orthogonal two-move isolation fixture." + } + ] +} diff --git a/research/pr3190-distinct-axis-basis-isolation/verify.py b/research/pr3190-distinct-axis-basis-isolation/verify.py new file mode 100644 index 0000000000..a59ce83d9d --- /dev/null +++ b/research/pr3190-distinct-axis-basis-isolation/verify.py @@ -0,0 +1,355 @@ +#!/usr/bin/env python3 +"""Reproduce the singleton census and test basis-character isolation.""" + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / "research" / "rank7-idle-star-stream-obstruction")) + +import algebra as A # noqa: E402 +import source as S # noqa: E402 + +RESULT = HERE / "RESULT.json" +PORTS = 112 +AXIS_LIMIT = 1 << 73 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load_port_contexts(): + """Authenticate the full fill, then independently group all owner-zero rows.""" + base_context = S.load_context() + vendor = S.PACKAGE / "vendor" + base = S.decode(S.read_bytes(vendor / "BASE-FILL.json.gz"))["rows"] + journal = S.decode(S.read_bytes(vendor / "EXCHANGE.json")) + edits = S.journal_edits(base, journal) + rows = defaultdict(list) + for index in range(S.TOTAL_ROWS): + row = edits[index] if index in edits else S.lifted_row(base, index) + if row[2] == 0: + require(type(row[4]) is int and 0 <= row[4] < PORTS, "owner-zero port range") + rows[row[4]].append(row) + require(set(rows) == set(range(PORTS)), "all owner-zero ports present") + require(rows[0] == base_context["rows"], "port-zero source projection") + recipes = S.decode(S.read_bytes(S.ROOT / S.PHASES))["recipes"] + require(len(recipes) == PORTS, "recipe count") + require(all(recipe["port"] == port for port, recipe in enumerate(recipes)), "recipe order") + return base_context, rows, recipes + + +def host_and_residual(context): + """Reconstruct hosted slices and remaining axes for one exact port.""" + recipe, plan = context["recipe"], context["plan"] + used, hosts = defaultdict(set), defaultdict(list) + for time, helper, owner, child, port, offset in context["rows"]: + require(owner == 0 and port == recipe["port"], "role owner and port") + require(0 <= time < len(context["order"]), "host chronology index") + require(0 <= child < len(recipe["idle_children"]), "host child index") + stage, replica = context["order"][time] + tag = context["dispatch"][stage, replica % 74] + width = context["providers"][tag]["widths"][helper] + axes = [int(v) for v in recipe["idle_children"][child]["orthogonal_axes"]] + require(type(width) is int and width > 0, "positive provider width") + require(0 <= offset and offset + width <= len(axes), "hosted slice bounds") + positions = set(range(offset, offset + width)) + require(not (used[child] & positions), "hosted slice overlap") + used[child].update(positions) + stream = 2 * plan["pairs"][str(child)] + plan["sides"][str(child)] + hosts[time].append((stream, axes[offset : offset + width])) + + residual, full = {}, {} + for child, entry in enumerate(recipe["idle_children"]): + axes = [int(v) for v in entry["orthogonal_axes"]] + require(all(type(v) is int and 0 < v < AXIS_LIMIT for v in axes), "73-bit axes") + require( + all(A.dot(v, w) == int(i == j) + for i, v in enumerate(axes) for j, w in enumerate(axes)), + "within-child orthonormal axes", + ) + require(used[child] == set(range(len(used[child]))), "compact hosted prefix") + full[child] = len(axes) + residual[child] = [v for i, v in enumerate(axes) if i not in used[child]] + return residual, hosts, full + + +def scalar(character): + return [ + [A.rotate((1, 0), character.bit_count()) if i == j else (0, 0) + for j in range(8)] + for i in range(8) + ] + + +def replay(context, blocks, hosts, residual, character): + """Run the unchanged eight-stream event semantics on one residual assignment.""" + require(type(character) is int and 0 <= character < AXIS_LIMIT, "73-bit character") + matrix = A.identity() + for time, (stage, replica) in enumerate(context["order"]): + for stream, axes in hosts.get(time, ()): + A.phase(matrix, stream, sum(A.dot(character, axis) for axis in axes)) + if replica == 0: + for event in blocks[stage]: + A.data_event(matrix, event, context, residual, character) + return matrix + + +def declared_rule(recipe, current, donor, receiver, axis): + """The stated PR3190 per-axis commuting condition, without its move code.""" + translations = [ + int(stage[key]) + for stage in recipe["stage_alignment"] + for key in ("entry_X", "exit_X", "entry_Y", "exit_Y") + ] + translations.append(int(recipe["terminal_Y_translation"])) + translations.extend( + int(recipe["idle_children"][child]["translation_after"]) + for child in (donor, receiver) + ) + return ( + donor != receiver + and axis in current[donor] + and all(A.dot(axis, other) == 0 + for other in current[receiver] + translations) + ) + + +def apply_moves(recipe, original, moves): + """Apply distinct moves in order, checking the declared rule and final ranks.""" + final = {child: list(axes) for child, axes in original.items()} + moved = set() + for donor, receiver, axis in moves: + require((donor, axis) not in moved, "one source axis cannot be moved twice") + require(declared_rule(recipe, final, donor, receiver, axis), "declared move rule") + moved.add((donor, axis)) + final[donor].remove(axis) + final[receiver].append(axis) + for axes in final.values(): + require(len(axes) <= 51, "final child rank cap") + require( + all(A.dot(v, w) == int(i == j) + for i, v in enumerate(axes) for j, w in enumerate(axes)), + "final within-child orthonormal axes", + ) + return final + + +def difference_count(left, right): + return sum(left[i][j] != right[i][j] for i in range(8) for j in range(8)) + + +def differences(left, right): + return [ + [i, j, list(left[i][j]), list(right[i][j])] + for i in range(8) + for j in range(8) + if left[i][j] != right[i][j] + ] + + +def fail_control(call, label): + try: + call() + except ValueError: + return + raise ValueError(label + " failure control was accepted") + + +def find_pair_control(port, recipe, original, candidates): + by_axis = defaultdict(list) + for move in candidates: + by_axis[move[2]].append(move) + axes = sorted(by_axis) + for left_index, left_axis in enumerate(axes): + for right_axis in axes[left_index + 1 :]: + if A.dot(left_axis, right_axis) != 0: + continue + for left in by_axis[left_axis]: + for right in by_axis[right_axis]: + try: + bundled = apply_moves(recipe, original, [left, right]) + except ValueError: + continue + return left, right, bundled + return None + + +def census(): + base_context, rows_by_port, recipes = load_port_contexts() + blocks = A.stage_blocks(base_context["template"]) + per_port, summary = {}, Counter() + pair_control = None + positive_control = None + for port in range(PORTS): + context = dict(base_context, rows=rows_by_port[port], recipe=recipes[port]) + residual, hosts, full = host_and_residual(context) + counts = Counter() + baseline_by_axis = {} + candidates = [] + for donor, axes in residual.items(): + if not axes or len(axes) == full[donor]: + continue # only a hosted child with a nonempty remainder is a donor + for receiver in residual: + if receiver == donor or full[receiver] == 0: + continue + for axis in axes: + counts["raw_candidates"] += 1 + if not declared_rule(recipes[port], residual, donor, receiver, axis): + counts["rule_rejects"] += 1 + continue + counts["rule_passes"] += 1 + try: + final = apply_moves(recipes[port], residual, [(donor, receiver, axis)]) + except ValueError: + counts["final_validity_rejects"] += 1 + continue + counts["final_valid_singletons"] += 1 + candidates.append((donor, receiver, axis)) + if axis not in baseline_by_axis: + baseline = replay(context, blocks, hosts, residual, axis) + require(baseline == scalar(axis), "singleton-character scalar baseline") + baseline_by_axis[axis] = baseline + after = replay(context, blocks, hosts, final, axis) + delta = difference_count(baseline_by_axis[axis], after) + if delta: + counts["changed_at_own_character"] += 1 + else: + counts["preserved_at_own_character"] += 1 + + require(counts["preserved_at_own_character"] == 0, + "some admissible singleton preserved the operator at its moved-axis character") + counts["distinct_singleton_characters"] = len(baseline_by_axis) + for key in ( + "raw_candidates", + "rule_rejects", + "rule_passes", + "final_validity_rejects", + "final_valid_singletons", + "changed_at_own_character", + "preserved_at_own_character", + "distinct_singleton_characters", + ): + counts.setdefault(key, 0) + if positive_control is None and candidates: + donor, receiver, axis = candidates[0] + empty = replay(context, blocks, hosts, residual, axis) + require(empty == baseline_by_axis[axis], "empty-overlay positive control") + fail_control( + lambda: apply_moves(recipes[port], residual, [(donor, donor, axis)]), + "self-transfer", + ) + alternative = next( + (v for child_axes in recipes[port]["idle_children"] + for v in map(int, child_axes["orthogonal_axes"]) + if v not in residual[donor]), + None, + ) + if alternative is not None: + fail_control( + lambda: apply_moves(recipes[port], residual, [(donor, receiver, alternative)]), + "axis absent from donor", + ) + positive_control = { + "port": port, + "character": axis, + "empty_overlay_equals_baseline": True, + "self_transfer_rejected": True, + "axis_absent_from_donor_rejected": alternative is not None, + } + + if pair_control is None and candidates: + pair = find_pair_control(port, recipes[port], residual, candidates) + if pair is not None: + left, right, bundled = pair + left_single = apply_moves(recipes[port], residual, [left]) + right_single = apply_moves(recipes[port], residual, [right]) + comparisons = [] + for move, single in ((left, left_single), (right, right_single)): + axis = move[2] + require(A.dot(left[2], right[2]) == 0, "pair-control orthogonality") + baseline = baseline_by_axis[axis] + singleton_matrix = replay(context, blocks, hosts, single, axis) + bundle_matrix = replay(context, blocks, hosts, bundled, axis) + require(singleton_matrix != baseline, "pair-control singleton changes") + require( + bundle_matrix == singleton_matrix, + "two-move isolation equality", + ) + comparisons.append({ + "character": axis, + "baseline": baseline, + "singleton": singleton_matrix, + "bundle": bundle_matrix, + "singleton_difference_count": difference_count(baseline, singleton_matrix), + "singleton_differences": differences(baseline, singleton_matrix), + }) + pair_control = { + "port": port, + "moves": [ + [left[0], left[1], left[2]], + [right[0], right[1], right[2]], + ], + "characters": [left[2], right[2]], + "axis_dot": 0, + "bundle_equals_each_singleton_at_its_character": True, + "character_comparisons": comparisons, + } + per_port[str(port)] = dict(counts) + summary.update(counts) + + require(positive_control is not None, "at least one positive control") + require(pair_control is not None, "at least one legal orthogonal pair control") + require(summary["raw_candidates"] == 9384, "expected raw hosted-remainder domain") + require(summary["rule_passes"] == 3809, "expected declared-rule count") + require(summary["final_valid_singletons"] == 3809, "expected final-valid singleton count") + require(summary["changed_at_own_character"] == 3809, "every admissible singleton changes") + require(summary["rule_rejects"] == 5575, "expected declared-rule rejects") + require(summary["final_validity_rejects"] == 0, "no post-rule singleton rejection") + no_pass_ports = sum(p["rule_passes"] == 0 for p in per_port.values()) + require(no_pass_ports == 47, "expected ports with no singleton admitted by the declared rule") + summary["ports_with_no_rule_passes"] = no_pass_ports + result = { + "status": "PASS_DISTINCT_AXIS_OVERLAY_ISOLATION", + "source_base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "audited_owner_replica": 0, + "ports": PORTS, + "authenticated_fill_rows": S.TOTAL_ROWS, + "fill_payload_sha256": S.FILL_SHA, + "cover": "identity", + "operator": "exact eight-stream Gaussian-integer replay from PR3187", + "singleton_domain": "hosted remainder donor with nonempty remainder; distinct receiver with nonempty full axis list (hosted receivers admitted); PR3190 commuting rule; final rank <= 51 and within-child orthonormality", + "per_port": per_port, + "summary": dict(summary), + "positive_control": positive_control, + "orthogonal_pair_control": pair_control, + "scope_note": "The receiver domain relaxes PR3190's construction restrictions. The theorem covers only finite legal overlays whose moved axes are pairwise orthogonal and whose components lie in that enumerated singleton domain.", + } + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="write the regenerated RESULT.json") + args = parser.parse_args() + result = json.loads(json.dumps(census())) + if args.write: + RESULT.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + else: + expected = json.loads(S.read_bytes(RESULT)) + require(result == expected, "stored RESULT.json differs from exact replay") + counts = result["summary"] + print( + "PASS_DISTINCT_AXIS_OVERLAY_ISOLATION ports=112 candidates=%d admissible=%d changed=%d pair_control=yes" + % (counts["raw_candidates"], counts["changed_at_own_character"], counts["changed_at_own_character"]) + ) + + +if __name__ == "__main__": + main()