diff --git a/research/pr3190-remainder-stream-obstruction/CENSUS.json b/research/pr3190-remainder-stream-obstruction/CENSUS.json new file mode 100644 index 0000000000..dd461df060 --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/CENSUS.json @@ -0,0 +1,410 @@ +{ + "ports": { + "0": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "1": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "10": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "100": { + "rule_rejects": 68 + }, + "101": { + "rule_rejects": 68 + }, + "102": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "103": { + "rule_rejects": 68 + }, + "104": { + "rule_rejects": 68 + }, + "105": { + "rule_rejects": 68 + }, + "106": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "107": { + "rule_rejects": 68 + }, + "108": { + "rule_rejects": 68 + }, + "109": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "11": { + "rule_rejects": 68 + }, + "110": { + "rule_rejects": 68 + }, + "111": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "12": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "13": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "14": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "15": { + "rule_rejects": 68 + }, + "16": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "17": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "18": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "19": { + "rule_rejects": 68 + }, + "2": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "20": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "21": { + "rule_rejects": 68 + }, + "22": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "23": { + "rule_rejects": 68 + }, + "24": { + "rule_rejects": 68 + }, + "25": { + "operator_changed": 104, + "rule_rejects": 32 + }, + "26": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "27": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "28": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "29": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "3": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "30": { + "operator_changed": 52, + "rule_rejects": 84 + }, + "31": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "32": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "33": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "34": { + "operator_changed": 52, + "rule_rejects": 84 + }, + "35": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "36": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "37": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "38": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "39": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "4": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "40": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "41": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "42": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "43": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "44": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "45": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "46": { + "operator_changed": 91, + "rule_rejects": 45 + }, + "47": { + "operator_changed": 52, + "rule_rejects": 84 + }, + "48": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "49": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "5": { + "rule_rejects": 68 + }, + "50": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "51": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "52": { + "operator_changed": 78, + "rule_rejects": 58 + }, + "53": { + "operator_changed": 39, + "rule_rejects": 97 + }, + "54": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "55": { + "rule_rejects": 68 + }, + "56": { + "rule_rejects": 68 + }, + "57": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "58": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "59": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "6": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "60": { + "rule_rejects": 68 + }, + "61": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "62": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "63": { + "rule_rejects": 68 + }, + "64": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "65": { + "rule_rejects": 68 + }, + "66": { + "rule_rejects": 68 + }, + "67": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "68": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "69": { + "rule_rejects": 68 + }, + "7": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "70": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "71": { + "rule_rejects": 68 + }, + "72": { + "rule_rejects": 68 + }, + "73": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "74": { + "rule_rejects": 68 + }, + "75": { + "rule_rejects": 68 + }, + "76": { + "rule_rejects": 68 + }, + "77": { + "rule_rejects": 68 + }, + "78": { + "rule_rejects": 68 + }, + "79": { + "rule_rejects": 68 + }, + "8": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "80": { + "rule_rejects": 68 + }, + "81": { + "rule_rejects": 68 + }, + "82": { + "rule_rejects": 68 + }, + "83": { + "rule_rejects": 68 + }, + "84": { + "operator_changed": 52, + "rule_rejects": 84 + }, + "85": { + "rule_rejects": 136 + }, + "86": { + "rule_rejects": 68 + }, + "87": { + "rule_rejects": 68 + }, + "88": { + "rule_rejects": 68 + }, + "89": { + "rule_rejects": 68 + }, + "9": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "90": { + "rule_rejects": 68 + }, + "91": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "92": { + "rule_rejects": 68 + }, + "93": { + "rule_rejects": 68 + }, + "94": { + "rule_rejects": 68 + }, + "95": { + "rule_rejects": 68 + }, + "96": { + "rule_rejects": 68 + }, + "97": { + "operator_changed": 52, + "rule_rejects": 16 + }, + "98": { + "rule_rejects": 68 + }, + "99": { + "rule_rejects": 68 + } + }, + "summary": { + "operator_changed": 3809, + "rule_rejects": 5575 + }, + "survivors": [] +} diff --git a/research/pr3190-remainder-stream-obstruction/README.md b/research/pr3190-remainder-stream-obstruction/README.md new file mode 100644 index 0000000000..3ba5047e16 --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/README.md @@ -0,0 +1,102 @@ +# PR3190's remainder moves change the physical operator + +**Scoped negative result. No new κ; the selected record is unchanged.** + +[PR #3190](https://github.com/CrocSwap/integer-mult-bounds/pull/3190) (Rohan Arun, +head `5e4a3235`) moves axes from idle **remainder** children, hosted or not, +into fully idle receivers. Its declared per-axis rule is the PR1252 commuting +rule. The pending candidates [#3198](https://github.com/CrocSwap/integer-mult-bounds/pull/3198), +[#3200](https://github.com/CrocSwap/integer-mult-bounds/pull/3200) and +[#3251](https://github.com/CrocSwap/integer-mult-bounds/pull/3251) inherit these +moves. #3198 reuses #3190's profile, and #3200 and #3251 list the same first moves +in their own MOVES files. [PR #3187](https://github.com/CrocSwap/integer-mult-bounds/pull/3187), +#3196, #3199 and #3204 refute #3184's star moves among **unhosted** 48s. #3204 +explicitly leaves hosted instances out. This package closes that gap for the +literal remainder donations. + +## Result + +At owner replica 0, port 0, #3190 commits exactly two moves: axis `2^72` from +child 14 to child 8, and from child 15 to child 10. Children 14 and 15 host 31 +of their 32 axes, so each donor is a **rank-1 hosted remainder** `[2^72]`. Both +moves pass #3190's declared rule: the axis commutes with the receiver's current +axes, all stage entry/exit X and Y translations, the terminal Y translation and +both terminal translations. The rank cap and orthonormality also hold. + +Under the unchanged completed local-invocation contract, PR3187's exact +eight-stream Gaussian-integer replay gives the scalar baseline `i·I_8` at Fourier +character `2^72`. The overlay changes **10 entries**: + +- move 14→8 alone (stream 2 → 6) changes 5 entries, for example `(6,6): i → −1`; +- move 15→10 alone (stream 3 → 7) changes the other 5, for example `(7,7): i → −1`; +- the joint change is exactly the union of the two. + +So neither move preserves the operator, and they do not cancel each other. + +**Census.** For all **112 ports** of owner replica 0, the 448 committed moves pass +the declared rule. The baseline equals the scalar operator at every moved-axis +character, yet the operator changes in **every** port. In 56 ports the moves are +the two hosted-remainder donations above. The other 56 carry #3184-type star moves +among unhosted children, which is consistent with #3187. + +**Every single-axis remainder transfer fails too.** `census.py` enumerates every +hosted child with a nonempty remainder as donor, every other idle child as receiver +and every remainder axis, at all 112 ports of owner replica 0. Of these, **3,809** +pass #3190's declared rule (5,575 do not). **All 3,809** change the exact operator +at their own moved-axis character, and none survives. In 47 ports no transfer passes +the rule at all. `CENSUS.json` stores the per-port counts. + +## Consequence and limits + +The literal move sets of #3190, #3198, #3200 and #3251 are not operator-preserving +under their stated contract. Their claimed gains over #3148 come entirely from +these moves, so this construction does not support them. At owner replica 0, no +single-axis remainder transfer survives either. Multi-axis or simultaneous +transfers, other replicas' hostings, and repaired or rescheduled exchanges are not +covered. Other owner replicas are not replayed; the literal +counterexample is enough to reject the move set as committed. #3220's repair-cost +bound and native, owner and outer obligations are separate. + +## Method and independence + +`obstruction.py` imports PR3187's `algebra.py` and `source.py` **unchanged** from +`research/rank7-idle-star-stream-obstruction`. They supply the fill authentication +(all 2,717,280 rows, payload `8f4d6965…`), the operator model and the data-event +semantics. This package adds the per-port projection of owner replica 0, +hosted-remainder residuals, #3190's declared rule and the comparison. It is a new +**binding** of an existing checker to a new candidate, not an independent +reimplementation of the operator model. #3190's `MOVES.json.gz` is vendored +byte-for-byte and pinned to its head. + +## Reproduce + +```sh +python3 -B research/pr3190-remainder-stream-obstruction/verify.py # port-0 witness, ~35 s +python3 -B research/pr3190-remainder-stream-obstruction/verify.py --all-ports # all 112 ports +python3 -B research/pr3190-remainder-stream-obstruction/census.py # 9,384 candidates, ~90 s +python3 scripts/research_package.py --package research/pr3190-remainder-stream-obstruction --check-only +``` + +Standard library only. Controls reject an axis outside the donor remainder and a +self-move. An empty overlay leaves the operator unchanged. Run locally with +Python 3.10.6; the registered Python 3.12 replay was not run. + +## Open next questions + +No single-axis remainder transfer survives at owner replica 0. Can a written +argument, extending #3204's rigidity proof to hosted children 4, 6, 14 and 15, +cover simultaneous transfers and every replica's hosting? That would turn this +finite census into a theorem that #3190's mechanism gives no legal gain, so that +the chain falls back to #3148. Repairs (#3220) and a changed schedule would be +the remaining routes. + +## Credit + +Nick Petalas (PR3187) supplied the exact replay used here. Gareth Davidson (PR1387) +first identified the physical-stream obstruction. Gonzalo-Mier (PR1252, #3196, +#3199), tekuuu (#3204) and Ross Richardson (#3220) supplied the related +obstructions. Rohan Arun (#3184, #3190, #3198, #3200, #3251) supplied the audited +moves; Jeremy Diviney (PR3148) the fill; Marius-Paul Dumitrean and the rank-seven +lineage the words. PR3133's notice is retained through PR3187's vendor directory. +Written by Claude (Anthropic) via Claude Code, in a session donated by Mark. +Apache-2.0. No human or formal review is claimed. diff --git a/research/pr3190-remainder-stream-obstruction/RESULT.json b/research/pr3190-remainder-stream-obstruction/RESULT.json new file mode 100644 index 0000000000..7cabcfb9d2 --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/RESULT.json @@ -0,0 +1,2356 @@ +{ + "admitted": false, + "owner_replica0_ports": { + "0": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "1": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "10": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "100": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "101": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "102": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "103": { + "changed": [ + [ + 5, + 6 + ], + [ + 13, + 6 + ], + [ + 21, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "104": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "105": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "106": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "107": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "108": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "109": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "11": { + "changed": [ + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 11, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "110": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "111": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "12": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "13": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "14": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "15": { + "changed": [ + [ + 2, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "16": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "17": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "18": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "19": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "2": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "20": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "21": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "22": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "23": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "24": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "25": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "26": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "27": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "28": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "29": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "3": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "30": { + "changed": [ + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 11, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "31": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "32": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "33": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "34": { + "changed": [ + [ + 2, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "35": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "36": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "37": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "38": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "39": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "4": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "40": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "41": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "42": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 7, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "43": { + "changed": [ + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 10, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "44": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "45": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "46": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "47": { + "changed": [ + [ + 1, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "48": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "49": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "5": { + "changed": [ + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 11, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "50": { + "changed": [ + [ + 1, + 3 + ], + [ + 3, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "51": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "52": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "53": { + "changed": [ + [ + 1, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "54": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "55": { + "changed": [ + [ + 1, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "56": { + "changed": [ + [ + 1, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "57": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "58": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "59": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "6": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "60": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "61": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "62": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "63": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 4, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "64": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "65": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "66": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "67": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "68": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "69": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 6, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "7": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "70": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "71": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 5, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "72": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 5, + 3 + ], + [ + 6, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "73": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "74": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 7, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "75": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 6, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "76": { + "changed": [ + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 4, + 3 + ], + [ + 5, + 3 + ], + [ + 9, + 3 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "77": { + "changed": [ + [ + 1, + 6 + ], + [ + 9, + 6 + ], + [ + 17, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "78": { + "changed": [ + [ + 2, + 6 + ], + [ + 10, + 6 + ], + [ + 18, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "79": { + "changed": [ + [ + 3, + 6 + ], + [ + 11, + 6 + ], + [ + 19, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "8": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "80": { + "changed": [ + [ + 4, + 6 + ], + [ + 12, + 6 + ], + [ + 20, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "81": { + "changed": [ + [ + 5, + 6 + ], + [ + 13, + 6 + ], + [ + 21, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "82": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "83": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "84": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "85": { + "changed": [ + [ + 2, + 6 + ], + [ + 10, + 6 + ], + [ + 18, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "86": { + "changed": [ + [ + 3, + 6 + ], + [ + 11, + 6 + ], + [ + 19, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "87": { + "changed": [ + [ + 4, + 6 + ], + [ + 12, + 6 + ], + [ + 20, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "88": { + "changed": [ + [ + 5, + 6 + ], + [ + 13, + 6 + ], + [ + 21, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "89": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "9": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "90": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "91": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "92": { + "changed": [ + [ + 3, + 6 + ], + [ + 11, + 6 + ], + [ + 19, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "93": { + "changed": [ + [ + 4, + 6 + ], + [ + 12, + 6 + ], + [ + 20, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "94": { + "changed": [ + [ + 5, + 6 + ], + [ + 13, + 6 + ], + [ + 21, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "95": { + "changed": [ + [ + 6, + 6 + ], + [ + 14, + 6 + ], + [ + 22, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "96": { + "changed": [ + [ + 7, + 6 + ], + [ + 15, + 6 + ], + [ + 23, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "97": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + }, + "98": { + "changed": [ + [ + 4, + 6 + ], + [ + 12, + 6 + ], + [ + 20, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + }, + "99": { + "changed": [ + [ + 5, + 6 + ], + [ + 13, + 6 + ], + [ + 21, + 6 + ] + ], + "hosted_remainder_donors": [], + "moves": 6 + } + }, + "port0_witness": { + "character_bit": 72, + "controls": { + "axis_not_in_donor_remainder": "rejected: PR3190 declared rule", + "empty_overlay_preserves_operator": "PASS", + "self_move": "rejected: PR3190 declared rule" + }, + "donor_streams": [ + 2, + 3 + ], + "isolated_differences": { + "14->8": [ + [ + 3, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 3, + 3, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + 5, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 5, + 3, + [ + 0, + 0 + ], + [ + 1, + -1 + ] + ], + [ + 6, + 6, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ] + ], + "15->10": [ + [ + 0, + 2, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 0, + 4, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 2, + 2, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + 2, + 4, + [ + 0, + 0 + ], + [ + 1, + -1 + ] + ], + [ + 7, + 7, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ] + ] + }, + "joint_differences": [ + [ + 0, + 2, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 0, + 4, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 2, + 2, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + 2, + 4, + [ + 0, + 0 + ], + [ + 1, + -1 + ] + ], + [ + 3, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 3, + 3, + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + 5, + 1, + [ + 0, + 0 + ], + [ + -1, + 1 + ] + ], + [ + 5, + 3, + [ + 0, + 0 + ], + [ + 1, + -1 + ] + ], + [ + 6, + 6, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ], + [ + 7, + 7, + [ + 0, + 1 + ], + [ + -1, + 0 + ] + ] + ], + "receiver_streams": [ + 6, + 7 + ], + "summary": { + "changed": [ + [ + 72, + 10 + ] + ], + "hosted_remainder_donors": [ + 14, + 15 + ], + "moves": 2 + } + }, + "selected_frontier_changed": false, + "status": "PASS_PR3190_REMAINDER_STREAM_COUNTEREXAMPLE" +} diff --git a/research/pr3190-remainder-stream-obstruction/SOURCES.json b/research/pr3190-remainder-stream-obstruction/SOURCES.json new file mode 100644 index 0000000000..e719aebb0f --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/SOURCES.json @@ -0,0 +1,115 @@ +{ + "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" + }, + { + "path": "research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz", + "usage": "input", + "git_blob": "e8401e6d138d9fcf9725530e7ae36d2db1386bda", + "sha256": "c76310bc9bdb7e693bdb8910e7ea084354251110a02ee629e3e8aad7418b695f", + "pin": "head:7f4ba27cb43666e974e369350bbc47dab0ce0456:research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz" + } + ] +} diff --git a/research/pr3190-remainder-stream-obstruction/TASK.json b/research/pr3190-remainder-stream-obstruction/TASK.json new file mode 100644 index 0000000000..0389b6e6b9 --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "463113d675af7410ac91d53a4fed51ec6494eb9a", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "changed", + "actual_scope": "Do PR3190's literal idle-remainder axis moves (inherited by PR3198, PR3200 and PR3251) preserve the exact eight-stream physical operator of the unchanged completed local-invocation contract?", + "scope_change_reason": "The leading pending candidates PR3190-PR3251 rest on hosted-remainder donations, which PR3187/PR3196/PR3199/PR3204 do not cover (PR3204 explicitly excludes hosted instances). Binding the existing exact replay to those literal moves is the missing implication.", + "bottleneck_link": "The whole claimed gain of PR3184-PR3251 over PR3148 comes from idle-axis moves; if the moves change the physical operator, those kappa claims are not supported by their construction.", + "budget_minutes": 60, + "stop_rule": "Stop at a literal, isolated, source-bound counterexample and the owner-replica-0 port census; do not attempt repairs or a new construction.", + "outcome": "negative-result", + "evidence": "verify.py --all-ports: at owner replica 0, all 112 ports' PR3190 move sets pass PR3190's declared rule yet change the exact operator at a moved-axis character, with the baseline equal to the scalar operator. In 56 ports the moves are the new hosted-remainder donations 14->8 and 15->10 of axis 2^72 (rank-1 remainders); each alone changes 5 entries at character 2^72. The other 56 ports carry PR3184-type star moves. census.py: all 3,809 rule-passing single-axis hosted-remainder transfers at owner replica 0 change the operator at their axis character; none survives.", + "author": "Claude (AI), session donated by Mark", + "ai_assistance": "Written and run by Claude (Anthropic) via Claude Code in a session donated by Mark; reuses PR3187's checker code unchanged; no independent human review.", + "open_questions": [ + { + "question": "Can PR3204's rigidity argument be extended to hosted children 4, 6, 14, 15, covering simultaneous transfers and every replica's hosting?", + "why_it_matters": "It would turn the finite replica-0 census into a proof that PR3190's mechanism yields no legal gain, so the chain falls back to PR3148.", + "first_step": "Check whether the schedule between each hosted remainder's sweep and each receiver's sweep preserves a common coordinate subspace, as in PR3204's first step.", + "blocked_by": "Repairs (PR3220), changed schedules, native and outer obligations remain separate." + } + ] +} diff --git a/research/pr3190-remainder-stream-obstruction/VERIFY.json b/research/pr3190-remainder-stream-obstruction/VERIFY.json new file mode 100644 index 0000000000..605bdf942d --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/VERIFY.json @@ -0,0 +1,45 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz", + "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}", + "-B", + "{package}/verify.py", + "--all-ports" + ], + "timeout_seconds": 600, + "checks": "authenticated PR3148 fill and PR3190 MOVES; port-0 witness with isolated moves and three controls; all 112 owner-replica-0 ports change the exact operator; equality with RESULT.json" + }, + { + "argv": [ + "{python}", + "-B", + "{package}/census.py" + ], + "timeout_seconds": 600, + "checks": "every single-axis hosted-remainder transfer passing PR3190's rule at owner replica 0 changes the exact operator; equality with CENSUS.json" + } + ] +} diff --git a/research/pr3190-remainder-stream-obstruction/census.py b/research/pr3190-remainder-stream-obstruction/census.py new file mode 100644 index 0000000000..dd0176bae1 --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/census.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Census of every single-axis idle-remainder transfer at owner replica 0. + +For each port, each hosted child with a nonempty remainder (donor), each other +idle child (receiver) and each remainder axis that passes PR3190's declared rule, +replay the exact operator at the moved-axis character. A transfer is rejected +when the operator changes there; survivors would still need every other +character. Compares with CENSUS.json (--write regenerates it). +""" +import json +import sys +from collections import Counter +from pathlib import Path + +import obstruction as O + + +def main(): + ctx0, rows, recipes = O.contexts() + blocks = O.A.stage_blocks(ctx0["template"]) + write = "--write" in sys.argv + args = [a for a in sys.argv[1:] if a != "--write"] + lo, hi = (int(args[0]), int(args[1])) if len(args) == 2 else (0, 112) + ports = {} + total = Counter() + survivors = [] + for p in range(lo, hi): + ctx = dict(ctx0, rows=rows[p], recipe=recipes[p]) + residual, hosts = O.residual_and_hosts(ctx) + full = [len(e["orthogonal_axes"]) for e in ctx["recipe"]["idle_children"]] + baseline = {} + stats = Counter() + for donor, axes in residual.items(): + if not axes or len(axes) == full[donor]: + continue # unhosted children are PR3204's domain + for receiver in residual: + if receiver == donor or full[receiver] == 0: + continue + for axis in axes: + if not O.declared_rule(ctx["recipe"], residual, donor, receiver, axis): + stats["rule_rejects"] += 1 + continue + try: + final = O.apply_moves(ctx["recipe"], residual, [(donor, receiver, axis)]) + except ValueError: + stats["cap_or_frame_rejects"] += 1 + continue + if axis not in baseline: + baseline[axis] = O.replay(ctx, blocks, hosts, residual, axis) + O.S.require(baseline[axis] == O.scalar(axis), "scalar baseline") + after = O.replay(ctx, blocks, hosts, final, axis) + if after == baseline[axis]: + stats["preserved_at_axis_character"] += 1 + survivors.append([p, donor, receiver, axis.bit_length() - 1]) + else: + stats["operator_changed"] += 1 + total.update(stats) + ports[str(p)] = dict(stats) + result = {"ports": ports, "summary": dict(total), "survivors": survivors} + O.S.require(not survivors, "a remainder transfer preserved the operator at its axis character") + path = Path(__file__).resolve().parent / "CENSUS.json" + if (lo, hi) == (0, 112): + if write: + path.write_text(json.dumps(result, indent=1, sort_keys=True) + "\n", encoding="utf-8") + else: + O.S.require(json.loads(path.read_text(encoding="utf-8")) == json.loads(json.dumps(result)), "stored CENSUS.json") + print("PASS_REMAINDER_TRANSFER_CENSUS ports=%d rule_passing=%d changed=%d survivors=0" % ( + hi - lo, total["operator_changed"], total["operator_changed"])) + + +if __name__ == "__main__": + main() diff --git a/research/pr3190-remainder-stream-obstruction/obstruction.py b/research/pr3190-remainder-stream-obstruction/obstruction.py new file mode 100644 index 0000000000..c86f4687dc --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/obstruction.py @@ -0,0 +1,122 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Bind PR3190's literal idle-axis moves to PR3187's exact eight-stream operator replay. + +The operator model, fill authentication and data-event semantics are imported +unchanged from research/rank7-idle-star-stream-obstruction (Nick Petalas/PR3187). +This module adds only: per-port projection of the authenticated fill for owner +replica 0, hosted-remainder residuals, PR3190's declared per-axis rule, and the +before/after comparison. It is not an independent reimplementation of PR3187. +""" +import hashlib +import sys +from collections import defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE.parent / "rank7-idle-star-stream-obstruction")) +import algebra as A # noqa: E402 +import source as S # noqa: E402 + +MOVES_SHA = "c76310bc9bdb7e693bdb8910e7ea084354251110a02ee629e3e8aad7418b695f" +AXIS72 = 1 << 72 + + +def load_moves(): + raw = S.read_bytes(HERE / "vendor" / "PR3190-MOVES.json.gz") + S.require(hashlib.sha256(raw).hexdigest() == MOVES_SHA, "PR3190 MOVES pin") + data = S.decode(raw) + S.require(data["columns"] == ["replica", "port", "donor_child", "receiver_child", "axis"], "MOVES columns") + S.require(len(data["moves"]) == 391964, "PR3190 move count") + by_port = defaultdict(list) + for replica, port, donor, receiver, axis in data["moves"]: + if replica == 0: + by_port[port].append((donor, receiver, int(axis))) + return by_port + + +def contexts(): + ctx0 = S.load_context() # authenticates PR3187's inputs and the complete PR3148 fill + vendor = S.PACKAGE / "vendor" + base = S.decode(S.read_bytes(vendor / "BASE-FILL.json.gz"))["rows"] + edits = S.journal_edits(base, S.decode(S.read_bytes(vendor / "EXCHANGE.json"))) + 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: + rows[row[4]].append(row) + S.require(rows[0] == ctx0["rows"], "port-0 projection equals PR3187's authenticated projection") + recipes = S.decode(S.read_bytes(S.ROOT / S.PHASES))["recipes"] + S.require(len(recipes) == 112 and all(r["port"] == p for p, r in enumerate(recipes)), "per-port recipes") + return ctx0, rows, recipes + + +def residual_and_hosts(ctx): + used, hosts = defaultdict(set), defaultdict(list) + for time, helper, owner, child, port, offset in ctx["rows"]: + stage, replica = ctx["order"][time] + width = ctx["providers"][ctx["dispatch"][stage, replica % 74]]["widths"][helper] + axes = list(map(int, ctx["recipe"]["idle_children"][child]["orthogonal_axes"])) + positions = set(range(offset, offset + width)) + S.require(offset >= 0 and offset + width <= len(axes) and not used[child] & positions, "hosted slice") + used[child] |= positions + stream = 2 * ctx["plan"]["pairs"][str(child)] + ctx["plan"]["sides"][str(child)] + hosts[time].append((stream, axes[offset:offset + width])) + residual = {} + for child, entry in enumerate(ctx["recipe"]["idle_children"]): + S.require(used[child] == set(range(len(used[child]))), "compact hosted prefix") + residual[child] = [int(v) for i, v in enumerate(entry["orthogonal_axes"]) if i not in used[child]] + return residual, hosts + + +def replay(ctx, blocks, hosts, residual, character): + matrix = A.identity() + for time, (stage, replica) in enumerate(ctx["order"]): + for stream, axes in hosts.get(time, ()): + A.phase(matrix, stream, sum(A.dot(character, v) for v in axes)) + if replica == 0: + for event in blocks[stage]: + A.data_event(matrix, event, ctx, residual, character) + return matrix + + +def declared_rule(recipe, current, donor, receiver, axis): + """PR3190's stated per-axis conditions, applied at the time the axis moves.""" + translations = [int(s[k]) for s in recipe["stage_alignment"] for k in ("entry_X", "exit_X", "entry_Y", "exit_Y")] + translations.append(int(recipe["terminal_Y_translation"])) + terminal = [int(recipe["idle_children"][c]["translation_after"]) for c in (donor, receiver)] + return (axis in current[donor] and donor != receiver + and all(A.dot(axis, v) == 0 for v in current[receiver] + translations + terminal)) + + +def apply_moves(recipe, residual, moves): + final = {c: list(v) for c, v in residual.items()} + for donor, receiver, axis in moves: + S.require(declared_rule(recipe, final, donor, receiver, axis), "PR3190 declared rule") + final[donor].remove(axis) + final[receiver].append(axis) + S.require(all(len(v) <= 51 for v in final.values()), "rank cap 51") + S.require(all(A.dot(v, w) == int(i == j) for axes in final.values() + for i, v in enumerate(axes) for j, w in enumerate(axes)), "orthonormal final axes") + return final + + +def diff(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 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 port_result(ctx, blocks, moves): + residual, hosts = residual_and_hosts(ctx) + final = apply_moves(ctx["recipe"], residual, moves) + full = [len(e["orthogonal_axes"]) for e in ctx["recipe"]["idle_children"]] + changed = [] + for character in sorted({axis for _, _, axis in moves}): + before = replay(ctx, blocks, hosts, residual, character) + after = replay(ctx, blocks, hosts, final, character) + S.require(before == scalar(character), "baseline equals the scalar operator") + changed.append([character.bit_length() - 1, len(diff(before, after))]) + hosted = sorted({d for d, _, _ in moves if len(residual[d]) < full[d]}) + return dict(moves=len(moves), hosted_remainder_donors=hosted, changed=changed), residual, hosts diff --git a/research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz b/research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz new file mode 100644 index 0000000000..e8401e6d13 Binary files /dev/null and b/research/pr3190-remainder-stream-obstruction/vendor/PR3190-MOVES.json.gz differ diff --git a/research/pr3190-remainder-stream-obstruction/verify.py b/research/pr3190-remainder-stream-obstruction/verify.py new file mode 100644 index 0000000000..f4a1ed675b --- /dev/null +++ b/research/pr3190-remainder-stream-obstruction/verify.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Reject PR3190's literal remainder moves with PR3187's exact physical-stream replay. + +Default: the port-0 witness, each move isolated, and controls. +--all-ports: all 112 ports of owner replica 0 (about 10 minutes). +--write: regenerate RESULT.json instead of comparing with it. +""" +import argparse +import json +from pathlib import Path + +import obstruction as O + +HERE = Path(__file__).resolve().parent + + +def witness(ctx, blocks, moves): + O.S.require(moves == [(14, 8, O.AXIS72), (15, 10, O.AXIS72)], "literal PR3190 port-0 moves") + summary, residual, hosts = O.port_result(ctx, blocks, moves) + O.S.require(residual[14] == residual[15] == [O.AXIS72], "rank-1 hosted remainders") + before = O.replay(ctx, blocks, hosts, residual, O.AXIS72) + isolated = {} + for move in moves: + key = "%d->%d" % move[:2] + after = O.replay(ctx, blocks, hosts, O.apply_moves(ctx["recipe"], residual, [move]), O.AXIS72) + isolated[key] = O.diff(before, after) + O.S.require(isolated[key], "each move alone changes the operator") + joint = O.diff(before, O.replay(ctx, blocks, hosts, O.apply_moves(ctx["recipe"], residual, moves), O.AXIS72)) + O.S.require(sorted(joint) == sorted(isolated["14->8"] + isolated["15->10"]), "disjoint isolated changes") + controls = {} + for label, bad in (("axis_not_in_donor_remainder", [(14, 8, 1 << 71)]), ("self_move", [(14, 14, O.AXIS72)])): + try: + O.apply_moves(ctx["recipe"], residual, bad) + except ValueError as error: + controls[label] = "rejected: " + str(error) + else: + raise AssertionError("control accepted: " + label) + O.S.require(O.replay(ctx, blocks, hosts, O.apply_moves(ctx["recipe"], residual, []), O.AXIS72) == before, + "empty overlay preserves the operator") + controls["empty_overlay_preserves_operator"] = "PASS" + return dict(summary=summary, character_bit=72, donor_streams=[2, 3], receiver_streams=[6, 7], + isolated_differences=isolated, joint_differences=joint, controls=controls) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--all-ports", action="store_true") + parser.add_argument("--write", action="store_true") + args = parser.parse_args() + moves = O.load_moves() + ctx0, rows, recipes = O.contexts() + blocks = O.A.stage_blocks(ctx0["template"]) + + def port(p): + return dict(ctx0, rows=rows[p], recipe=recipes[p]) + + got = {"status": "PASS_PR3190_REMAINDER_STREAM_COUNTEREXAMPLE", "admitted": False, + "selected_frontier_changed": False, "port0_witness": witness(port(0), blocks, moves[0])} + if args.all_ports or args.write: + ports = {str(p): O.port_result(port(p), blocks, moves[p])[0] for p in range(112)} + O.S.require(all(v["changed"] and all(n > 0 for _, n in v["changed"]) for v in ports.values()), "every port changes") + got["owner_replica0_ports"] = ports + path = HERE / "RESULT.json" + if args.write: + path.write_text(json.dumps(got, indent=1, sort_keys=True) + "\n", encoding="utf-8") + return + want = json.loads(path.read_text(encoding="utf-8")) + if not args.all_ports: + want.pop("owner_replica0_ports") + O.S.require(json.loads(json.dumps(got)) == want, "recomputed result differs from RESULT.json") + if args.all_ports: + print("PASS_PR3190_ALL_PORTS ports=112 changed=112 no_new_kappa") + else: + print("PASS_PR3190_REMAINDER_STREAM_COUNTEREXAMPLE port=0 character=2^72 differences=10 isolated=5+5 no_new_kappa") + + +if __name__ == "__main__": + main()