diff --git a/research/bit-nine-deadline-relay-floor/.gitattributes b/research/bit-nine-deadline-relay-floor/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/bit-nine-deadline-relay-floor/CREDITS.md b/research/bit-nine-deadline-relay-floor/CREDITS.md new file mode 100644 index 0000000000..4872b2f30e --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/CREDITS.md @@ -0,0 +1,31 @@ +# Credit and source boundaries + +Prepared by Ali Romman with substantial OpenAI Codex assistance in research, +implementation, verification and writing. New work is Apache-2.0. + +Ali Romman's [PR #7741](https://github.com/CrocSwap/integer-mult-bounds/pull/7741) +supplied the [fixed quotient and direct-bundle proof](https://github.com/aliromman/integer-mult-bounds/blob/33817d65c801232f1e07355f43ec6040a41e7c7e/research/bit-all-bundle-price-floor/PROOF.md), +[complete support/coset certificate](https://github.com/aliromman/integer-mult-bounds/blob/33817d65c801232f1e07355f43ec6040a41e7c7e/research/bit-all-bundle-price-floor/RESULT.json), +and [verifier](https://github.com/aliromman/integer-mult-bounds/blob/33817d65c801232f1e07355f43ec6040a41e7c7e/research/bit-all-bundle-price-floor/verify.py). +Its complete eighteen-file package is retained unchanged and replayed. + +Nick Petalas supplied the full-donor reduction, nine exceptions and pair +checker in [PR #7739](https://github.com/CrocSwap/integer-mult-bounds/pull/7739). +Ali Romman's [PR #7723](https://github.com/CrocSwap/integer-mult-bounds/pull/7723) +supplied the fixed-library model and source attainments. Jerry Chen supplied +the selected caller in [PR #7001](https://github.com/CrocSwap/integer-mult-bounds/pull/7001). +The [retained credit file](https://github.com/aliromman/integer-mult-bounds/blob/33817d65c801232f1e07355f43ec6040a41e7c7e/research/bit-all-bundle-price-floor/CREDITS.md) +links their exact sources and preserves zxv, DreamingOfClouds, Cinna Davis +and earlier native/root credit. All source notices and licenses remain intact. + +The new contribution is the paid-component reduction, abstract tree bound, +complete nested-chain support census and arbitrary-relay conclusion at nine +deadlines. The predecessor's direct floor and 511 coset distances are reused +evidence, not new claims. Geometry and source replay remain shared code. +The second path enumeration is by the same author after source inspection; +no independent human or formal-kernel acceptance is claimed. + +SOURCE-PINS.json binds the retained publication bytes. SOURCES.json binds +only the base catalogue and selected record as provenance. No unmerged +source ancestry is asserted. No predecessor code, source global or frozen +byte is patched. diff --git a/research/bit-nine-deadline-relay-floor/PROOF.md b/research/bit-nine-deadline-relay-floor/PROOF.md new file mode 100644 index 0000000000..6c7a84a967 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/PROOF.md @@ -0,0 +1,194 @@ +# Arbitrary paid relays cannot improve nine BIT arrivals + +At each of the nine forward rank-seven arrivals into chart 0, the original +price `7^t` is minimum even with an arbitrary finite network of paid nested +relay transfers on the retained charts, for `0=R^t` for `0= R^t, 0=48>30 +``` + +The unchanged predecessor reruns its rational nesting, full-span exclusions +and 4,626 singleton plus 478,764 pair checks. A new coordinate-set interpreter +agrees with its packed interpreter on all 5,742 paid rows and checks every +original-source attainment. The new certificate checks 4,112 later donor +library equalities, all 511 coset vectors, support caps and the strict budget. +Controls reject four false caps and nine arrivals used at their own deadline. +The declared source geometry remains shared; this is not blind human review. + +The runner authenticates base provenance through Git. The direct verifier +runs from an exported package without Git or network access and checks all +eight retained source hashes. No source globals or frozen code are patched. +The selected cold replay, other predecessor full suites, Lean, Docker and +physical delivery or storage were not run. All five framework assumptions +remain. The selected frontier is unchanged. + +## Selection and boundary + +Base e54523517d0f03e58352e647c403a5af3e525a57, priority revision 8. The selected +bindings pass; the catalogue assessment is older. TASK.json records the +changed bit-helper-contract scope. The parent handoff explicitly leaves +these nine cases open. Exact-source open/closed intake, current PR bodies +and live handoffs found no matching claim in their coverage. Sparse notes +and unpublished work remain coverage limits. + +The contract fixes libraries, independent inputs, destinations, target rows +and deadlines. It permits any number of direct donors, but no new chart, +relay, helper relation or adaptive library. With productive targets and all +other caller terms fixed, its best compatible signed-margin gain is zero. + +## Open next questions + +Can one paid relay change the causal library enough to permit a complete +saving? Specify its source, intermediate chart, arrival deadline, formation, +retention and restoration first. Then compare the full added and removed +power tariff. The present proof supplies no relay price or physical program. +The arbitrary-arity search in the fixed original libraries is complete; +another donor-count census is not a useful continuation of this model. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. Nick Petalas's +reduction and checker, Jerry Chen's selected caller, and all native and caller +predecessors retain their credit and unchanged notices in CREDITS.md. diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/RESULT.json b/research/bit-nine-deadline-relay-floor/retained/pr7741/RESULT.json new file mode 100644 index 0000000000..ed9d6fa4f2 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/RESULT.json @@ -0,0 +1,3827 @@ +{ + "base_destination_rank": 524, + "cases": [ + { + "clock": 26861, + "cosets": 1, + "destination": 0, + "distance_histogram": { + "56": 1 + }, + "free_dimension": 0, + "minimum_distance": 56, + "minimum_selector": 0, + "old_rank": 7, + "source": 510, + "target": "0x7faa33a86730e2ae16b0d6b0ca69" + }, + { + "clock": 26869, + "cosets": 2, + "destination": 0, + "distance_histogram": { + "58": 1, + "60": 1 + }, + "free_dimension": 1, + "minimum_distance": 58, + "minimum_selector": 1, + "old_rank": 7, + "source": 511, + "target": "0x7fd5cca866cf1d51d6b0e94f0a69" + }, + { + "clock": 26877, + "cosets": 4, + "destination": 0, + "distance_histogram": { + "52": 2, + "58": 1, + "60": 1 + }, + "free_dimension": 2, + "minimum_distance": 52, + "minimum_selector": 1, + "old_rank": 7, + "source": 512, + "target": "0x33335532abfce1e470e970e97899" + }, + { + "clock": 26885, + "cosets": 8, + "destination": 0, + "distance_histogram": { + "50": 1, + "52": 1, + "54": 2, + "58": 3, + "60": 1 + }, + "free_dimension": 3, + "minimum_distance": 50, + "minimum_selector": 2, + "old_rank": 7, + "source": 513, + "target": "0x4ccc55ccabff1e1470d6b0d68799" + }, + { + "clock": 26893, + "cosets": 16, + "destination": 0, + "distance_histogram": { + "51": 5, + "53": 1, + "59": 7, + "61": 3 + }, + "free_dimension": 4, + "minimum_distance": 51, + "minimum_selector": 2, + "old_rank": 7, + "source": 514, + "target": "0x33666664cccffb4599999999b20f" + }, + { + "clock": 26901, + "cosets": 32, + "destination": 0, + "distance_histogram": { + "50": 2, + "51": 3, + "52": 5, + "53": 3, + "54": 3, + "56": 1, + "57": 2, + "58": 3, + "59": 5, + "60": 2, + "61": 3 + }, + "free_dimension": 5, + "minimum_distance": 50, + "minimum_selector": 6, + "old_rank": 7, + "source": 515, + "target": "0x78700f0fe1e257f1c3fc3c03c7f0" + }, + { + "clock": 26909, + "cosets": 64, + "destination": 0, + "distance_histogram": { + "111": 1, + "50": 6, + "51": 5, + "52": 12, + "53": 8, + "54": 2, + "55": 2, + "57": 5, + "58": 4, + "59": 8, + "60": 8, + "61": 3 + }, + "free_dimension": 6, + "minimum_distance": 50, + "minimum_selector": 17, + "old_rank": 7, + "source": 516, + "target": "0x785a3c5878d2b55feab32ab33266" + }, + { + "clock": 26917, + "cosets": 128, + "destination": 0, + "distance_histogram": { + "48": 1, + "49": 3, + "50": 2, + "51": 14, + "52": 19, + "53": 17, + "54": 6, + "55": 2, + "56": 2, + "57": 6, + "58": 17, + "59": 19, + "60": 14, + "61": 2, + "62": 3, + "63": 1 + }, + "free_dimension": 7, + "minimum_distance": 48, + "minimum_selector": 83, + "old_rank": 7, + "source": 517, + "target": "0x2d25f094b54994c6a97fe6569133" + }, + { + "clock": 26925, + "cosets": 256, + "destination": 0, + "distance_histogram": { + "48": 3, + "49": 9, + "50": 21, + "51": 23, + "52": 37, + "53": 23, + "54": 11, + "55": 1, + "56": 1, + "57": 11, + "58": 23, + "59": 37, + "60": 23, + "61": 21, + "62": 9, + "63": 3 + }, + "free_dimension": 8, + "minimum_distance": 48, + "minimum_selector": 20, + "old_rank": 7, + "source": 518, + "target": "0x1e165a581eb68ad2d9a9697fe955" + } + ], + "controls": { + "binary_sum_control": true, + "deadline_leak_controls": 9, + "false_cap_rejections": 4, + "strict_budget_control": true + }, + "donor_caps": { + "1": 1, + "2": 2, + "4": 17, + "6": 30 + }, + "donors": [ + { + "chart": 2, + "image_dimension": 1, + "rank": 1, + "support": "0x1", + "support_size": 1 + }, + { + "chart": 3, + "image_dimension": 1, + "rank": 1, + "support": "0x2", + "support_size": 1 + }, + { + "chart": 4, + "image_dimension": 1, + "rank": 1, + "support": "0x4", + "support_size": 1 + }, + { + "chart": 5, + "image_dimension": 1, + "rank": 1, + "support": "0x8", + "support_size": 1 + }, + { + "chart": 6, + "image_dimension": 1, + "rank": 1, + "support": "0x10", + "support_size": 1 + }, + { + "chart": 7, + "image_dimension": 1, + "rank": 1, + "support": "0x20", + "support_size": 1 + }, + { + "chart": 8, + "image_dimension": 1, + "rank": 1, + "support": "0x40", + "support_size": 1 + }, + { + "chart": 9, + "image_dimension": 1, + "rank": 1, + "support": "0x80", + "support_size": 1 + }, + { + "chart": 10, + "image_dimension": 1, + "rank": 1, + "support": "0x100", + "support_size": 1 + }, + { + "chart": 11, + "image_dimension": 1, + "rank": 1, + "support": "0x200", + "support_size": 1 + }, + { + "chart": 12, + "image_dimension": 1, + "rank": 1, + "support": "0x400", + "support_size": 1 + }, + { + "chart": 13, + "image_dimension": 1, + "rank": 1, + "support": "0x800", + "support_size": 1 + }, + { + "chart": 14, + "image_dimension": 1, + "rank": 1, + "support": "0x1000", + "support_size": 1 + }, + { + "chart": 15, + "image_dimension": 1, + "rank": 1, + "support": "0x2000", + "support_size": 1 + }, + { + "chart": 16, + "image_dimension": 1, + "rank": 1, + "support": "0x4000", + "support_size": 1 + }, + { + "chart": 17, + "image_dimension": 1, + "rank": 1, + "support": "0x8000", + "support_size": 1 + }, + { + "chart": 18, + "image_dimension": 1, + "rank": 1, + "support": "0x10000", + "support_size": 1 + }, + { + "chart": 19, + "image_dimension": 1, + "rank": 1, + "support": "0x20000", + "support_size": 1 + }, + { + "chart": 20, + "image_dimension": 1, + "rank": 1, + "support": "0x40000", + "support_size": 1 + }, + { + "chart": 21, + "image_dimension": 1, + "rank": 1, + "support": "0x80000", + "support_size": 1 + }, + { + "chart": 22, + "image_dimension": 1, + "rank": 1, + "support": "0x100000", + "support_size": 1 + }, + { + "chart": 23, + "image_dimension": 1, + "rank": 1, + "support": "0x200000", + "support_size": 1 + }, + { + "chart": 24, + "image_dimension": 1, + "rank": 1, + "support": "0x400000", + "support_size": 1 + }, + { + "chart": 25, + "image_dimension": 1, + "rank": 1, + "support": "0x800000", + "support_size": 1 + }, + { + "chart": 26, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000", + "support_size": 1 + }, + { + "chart": 27, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000", + "support_size": 1 + }, + { + "chart": 28, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000", + "support_size": 1 + }, + { + "chart": 29, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000", + "support_size": 1 + }, + { + "chart": 30, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000", + "support_size": 1 + }, + { + "chart": 31, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000", + "support_size": 1 + }, + { + "chart": 32, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000", + "support_size": 1 + }, + { + "chart": 33, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000", + "support_size": 1 + }, + { + "chart": 34, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000", + "support_size": 1 + }, + { + "chart": 35, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000", + "support_size": 1 + }, + { + "chart": 36, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000", + "support_size": 1 + }, + { + "chart": 37, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000", + "support_size": 1 + }, + { + "chart": 38, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000", + "support_size": 1 + }, + { + "chart": 39, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000", + "support_size": 1 + }, + { + "chart": 40, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000", + "support_size": 1 + }, + { + "chart": 41, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000", + "support_size": 1 + }, + { + "chart": 42, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000", + "support_size": 1 + }, + { + "chart": 43, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000", + "support_size": 1 + }, + { + "chart": 44, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000", + "support_size": 1 + }, + { + "chart": 45, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000", + "support_size": 1 + }, + { + "chart": 46, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000", + "support_size": 1 + }, + { + "chart": 47, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000", + "support_size": 1 + }, + { + "chart": 48, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000", + "support_size": 1 + }, + { + "chart": 49, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000", + "support_size": 1 + }, + { + "chart": 50, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000", + "support_size": 1 + }, + { + "chart": 51, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000", + "support_size": 1 + }, + { + "chart": 52, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000", + "support_size": 1 + }, + { + "chart": 53, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000000", + "support_size": 1 + }, + { + "chart": 54, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000000", + "support_size": 1 + }, + { + "chart": 55, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000000", + "support_size": 1 + }, + { + "chart": 56, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000000", + "support_size": 1 + }, + { + "chart": 57, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000000", + "support_size": 1 + }, + { + "chart": 58, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000000", + "support_size": 1 + }, + { + "chart": 59, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000000", + "support_size": 1 + }, + { + "chart": 60, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000000", + "support_size": 1 + }, + { + "chart": 61, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000000", + "support_size": 1 + }, + { + "chart": 62, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000000", + "support_size": 1 + }, + { + "chart": 63, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000000", + "support_size": 1 + }, + { + "chart": 64, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000000", + "support_size": 1 + }, + { + "chart": 65, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000000000", + "support_size": 1 + }, + { + "chart": 66, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000000000", + "support_size": 1 + }, + { + "chart": 67, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000000000", + "support_size": 1 + }, + { + "chart": 68, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000000000", + "support_size": 1 + }, + { + "chart": 69, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000000000", + "support_size": 1 + }, + { + "chart": 70, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000000000", + "support_size": 1 + }, + { + "chart": 71, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000000000", + "support_size": 1 + }, + { + "chart": 72, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000000000", + "support_size": 1 + }, + { + "chart": 73, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000000000", + "support_size": 1 + }, + { + "chart": 74, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000000000", + "support_size": 1 + }, + { + "chart": 75, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000000000", + "support_size": 1 + }, + { + "chart": 76, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000000000", + "support_size": 1 + }, + { + "chart": 77, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000000000000", + "support_size": 1 + }, + { + "chart": 78, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000000000000", + "support_size": 1 + }, + { + "chart": 79, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000000000000", + "support_size": 1 + }, + { + "chart": 80, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000000000000", + "support_size": 1 + }, + { + "chart": 81, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000000000000", + "support_size": 1 + }, + { + "chart": 82, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000000000000", + "support_size": 1 + }, + { + "chart": 83, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000000000000", + "support_size": 1 + }, + { + "chart": 84, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000000000000", + "support_size": 1 + }, + { + "chart": 85, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000000000000", + "support_size": 1 + }, + { + "chart": 86, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000000000000", + "support_size": 1 + }, + { + "chart": 87, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000000000000", + "support_size": 1 + }, + { + "chart": 88, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000000000000", + "support_size": 1 + }, + { + "chart": 89, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000000000000000", + "support_size": 1 + }, + { + "chart": 90, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000000000000000", + "support_size": 1 + }, + { + "chart": 91, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000000000000000", + "support_size": 1 + }, + { + "chart": 92, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000000000000000", + "support_size": 1 + }, + { + "chart": 93, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000000000000000", + "support_size": 1 + }, + { + "chart": 94, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000000000000000", + "support_size": 1 + }, + { + "chart": 95, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000000000000000", + "support_size": 1 + }, + { + "chart": 96, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000000000000000", + "support_size": 1 + }, + { + "chart": 97, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000000000000000", + "support_size": 1 + }, + { + "chart": 98, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000000000000000", + "support_size": 1 + }, + { + "chart": 99, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000000000000000", + "support_size": 1 + }, + { + "chart": 100, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000000000000000", + "support_size": 1 + }, + { + "chart": 101, + "image_dimension": 1, + "rank": 1, + "support": "0x8000000000000000000000000", + "support_size": 1 + }, + { + "chart": 102, + "image_dimension": 1, + "rank": 1, + "support": "0x10000000000000000000000000", + "support_size": 1 + }, + { + "chart": 103, + "image_dimension": 1, + "rank": 1, + "support": "0x20000000000000000000000000", + "support_size": 1 + }, + { + "chart": 104, + "image_dimension": 1, + "rank": 1, + "support": "0x40000000000000000000000000", + "support_size": 1 + }, + { + "chart": 105, + "image_dimension": 1, + "rank": 1, + "support": "0x80000000000000000000000000", + "support_size": 1 + }, + { + "chart": 106, + "image_dimension": 1, + "rank": 1, + "support": "0x100000000000000000000000000", + "support_size": 1 + }, + { + "chart": 107, + "image_dimension": 1, + "rank": 1, + "support": "0x200000000000000000000000000", + "support_size": 1 + }, + { + "chart": 108, + "image_dimension": 1, + "rank": 1, + "support": "0x400000000000000000000000000", + "support_size": 1 + }, + { + "chart": 109, + "image_dimension": 1, + "rank": 1, + "support": "0x800000000000000000000000000", + "support_size": 1 + }, + { + "chart": 110, + "image_dimension": 1, + "rank": 1, + "support": "0x1000000000000000000000000000", + "support_size": 1 + }, + { + "chart": 111, + "image_dimension": 1, + "rank": 1, + "support": "0x2000000000000000000000000000", + "support_size": 1 + }, + { + "chart": 112, + "image_dimension": 1, + "rank": 1, + "support": "0x4000000000000000000000000000", + "support_size": 1 + }, + { + "chart": 113, + "image_dimension": 2, + "rank": 2, + "support": "0x60", + "support_size": 2 + }, + { + "chart": 114, + "image_dimension": 2, + "rank": 2, + "support": "0x220", + "support_size": 2 + }, + { + "chart": 115, + "image_dimension": 2, + "rank": 2, + "support": "0x240", + "support_size": 2 + }, + { + "chart": 116, + "image_dimension": 2, + "rank": 2, + "support": "0x40400000000000", + "support_size": 2 + }, + { + "chart": 117, + "image_dimension": 2, + "rank": 2, + "support": "0x100400000000000", + "support_size": 2 + }, + { + "chart": 118, + "image_dimension": 2, + "rank": 2, + "support": "0x140000000000000", + "support_size": 2 + }, + { + "chart": 119, + "image_dimension": 2, + "rank": 2, + "support": "0x1800000000000", + "support_size": 2 + }, + { + "chart": 120, + "image_dimension": 2, + "rank": 2, + "support": "0x10800000000000", + "support_size": 2 + }, + { + "chart": 121, + "image_dimension": 2, + "rank": 2, + "support": "0x400800000000000", + "support_size": 2 + }, + { + "chart": 122, + "image_dimension": 2, + "rank": 2, + "support": "0x11000000000000", + "support_size": 2 + }, + { + "chart": 123, + "image_dimension": 2, + "rank": 2, + "support": "0x401000000000000", + "support_size": 2 + }, + { + "chart": 124, + "image_dimension": 2, + "rank": 2, + "support": "0x410000000000000", + "support_size": 2 + }, + { + "chart": 125, + "image_dimension": 2, + "rank": 2, + "support": "0x9", + "support_size": 2 + }, + { + "chart": 126, + "image_dimension": 2, + "rank": 2, + "support": "0x801", + "support_size": 2 + }, + { + "chart": 127, + "image_dimension": 2, + "rank": 2, + "support": "0x808", + "support_size": 2 + }, + { + "chart": 128, + "image_dimension": 2, + "rank": 2, + "support": "0x204000000000000000", + "support_size": 2 + }, + { + "chart": 129, + "image_dimension": 2, + "rank": 2, + "support": "0x1004000000000000000", + "support_size": 2 + }, + { + "chart": 130, + "image_dimension": 2, + "rank": 2, + "support": "0x1200000000000000000", + "support_size": 2 + }, + { + "chart": 131, + "image_dimension": 2, + "rank": 2, + "support": "0xa000000000000000", + "support_size": 2 + }, + { + "chart": 132, + "image_dimension": 2, + "rank": 2, + "support": "0x102000000000000000", + "support_size": 2 + }, + { + "chart": 133, + "image_dimension": 2, + "rank": 2, + "support": "0x108000000000000000", + "support_size": 2 + }, + { + "chart": 134, + "image_dimension": 2, + "rank": 2, + "support": "0x808000", + "support_size": 2 + }, + { + "chart": 135, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000000000000008000", + "support_size": 2 + }, + { + "chart": 136, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000000000000008000", + "support_size": 2 + }, + { + "chart": 137, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000000000000800000", + "support_size": 2 + }, + { + "chart": 138, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000000000000800000", + "support_size": 2 + }, + { + "chart": 139, + "image_dimension": 2, + "rank": 2, + "support": "0x1080000000000000000000000", + "support_size": 2 + }, + { + "chart": 140, + "image_dimension": 2, + "rank": 2, + "support": "0x20040000000", + "support_size": 2 + }, + { + "chart": 141, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000000040000000", + "support_size": 2 + }, + { + "chart": 142, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000000040000000", + "support_size": 2 + }, + { + "chart": 143, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000020000000000", + "support_size": 2 + }, + { + "chart": 144, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000020000000000", + "support_size": 2 + }, + { + "chart": 145, + "image_dimension": 2, + "rank": 2, + "support": "0x408000000000000000000", + "support_size": 2 + }, + { + "chart": 146, + "image_dimension": 2, + "rank": 2, + "support": "0x22000000000000", + "support_size": 2 + }, + { + "chart": 147, + "image_dimension": 2, + "rank": 2, + "support": "0x802000000000000", + "support_size": 2 + }, + { + "chart": 148, + "image_dimension": 2, + "rank": 2, + "support": "0x400002000000000000", + "support_size": 2 + }, + { + "chart": 149, + "image_dimension": 2, + "rank": 2, + "support": "0x820000000000000", + "support_size": 2 + }, + { + "chart": 150, + "image_dimension": 2, + "rank": 2, + "support": "0x400020000000000000", + "support_size": 2 + }, + { + "chart": 151, + "image_dimension": 2, + "rank": 2, + "support": "0x400800000000000000", + "support_size": 2 + }, + { + "chart": 152, + "image_dimension": 2, + "rank": 2, + "support": "0x8080000", + "support_size": 2 + }, + { + "chart": 153, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000000000000080000", + "support_size": 2 + }, + { + "chart": 154, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000000000080000", + "support_size": 2 + }, + { + "chart": 155, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000000000008000000", + "support_size": 2 + }, + { + "chart": 156, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000000008000000", + "support_size": 2 + }, + { + "chart": 157, + "image_dimension": 2, + "rank": 2, + "support": "0x2020000000000000000000000", + "support_size": 2 + }, + { + "chart": 158, + "image_dimension": 2, + "rank": 2, + "support": "0x80800000000", + "support_size": 2 + }, + { + "chart": 159, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000800000000", + "support_size": 2 + }, + { + "chart": 160, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000080000000000", + "support_size": 2 + }, + { + "chart": 161, + "image_dimension": 2, + "rank": 2, + "support": "0x20200000000000000", + "support_size": 2 + }, + { + "chart": 162, + "image_dimension": 2, + "rank": 2, + "support": "0x40200000000000000", + "support_size": 2 + }, + { + "chart": 163, + "image_dimension": 2, + "rank": 2, + "support": "0x60000000000000000", + "support_size": 2 + }, + { + "chart": 164, + "image_dimension": 2, + "rank": 2, + "support": "0x4200000", + "support_size": 2 + }, + { + "chart": 165, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000000000000200000", + "support_size": 2 + }, + { + "chart": 166, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000000000000000200000", + "support_size": 2 + }, + { + "chart": 167, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000000000004000000", + "support_size": 2 + }, + { + "chart": 168, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000000000000004000000", + "support_size": 2 + }, + { + "chart": 169, + "image_dimension": 2, + "rank": 2, + "support": "0x40400000000000000000000000", + "support_size": 2 + }, + { + "chart": 170, + "image_dimension": 2, + "rank": 2, + "support": "0x101000000000", + "support_size": 2 + }, + { + "chart": 171, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000001000000000", + "support_size": 2 + }, + { + "chart": 172, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000001000000000", + "support_size": 2 + }, + { + "chart": 173, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000100000000000", + "support_size": 2 + }, + { + "chart": 174, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000100000000000", + "support_size": 2 + }, + { + "chart": 175, + "image_dimension": 2, + "rank": 2, + "support": "0x1100000000000000000000", + "support_size": 2 + }, + { + "chart": 176, + "image_dimension": 2, + "rank": 2, + "support": "0x88000000000000", + "support_size": 2 + }, + { + "chart": 177, + "image_dimension": 2, + "rank": 2, + "support": "0x10008000000000000", + "support_size": 2 + }, + { + "chart": 178, + "image_dimension": 2, + "rank": 2, + "support": "0x800008000000000000", + "support_size": 2 + }, + { + "chart": 179, + "image_dimension": 2, + "rank": 2, + "support": "0x10080000000000000", + "support_size": 2 + }, + { + "chart": 180, + "image_dimension": 2, + "rank": 2, + "support": "0x800080000000000000", + "support_size": 2 + }, + { + "chart": 181, + "image_dimension": 2, + "rank": 2, + "support": "0x810000000000000000", + "support_size": 2 + }, + { + "chart": 182, + "image_dimension": 2, + "rank": 2, + "support": "0x420000", + "support_size": 2 + }, + { + "chart": 183, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000000000000020000", + "support_size": 2 + }, + { + "chart": 184, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000000000000400000", + "support_size": 2 + }, + { + "chart": 185, + "image_dimension": 2, + "rank": 2, + "support": "0x4200000000", + "support_size": 2 + }, + { + "chart": 186, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000000200000000", + "support_size": 2 + }, + { + "chart": 187, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000000000200000000", + "support_size": 2 + }, + { + "chart": 188, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000004000000000", + "support_size": 2 + }, + { + "chart": 189, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000000004000000000", + "support_size": 2 + }, + { + "chart": 190, + "image_dimension": 2, + "rank": 2, + "support": "0x8020000000000000000000", + "support_size": 2 + }, + { + "chart": 191, + "image_dimension": 2, + "rank": 2, + "support": "0x1004000000000000", + "support_size": 2 + }, + { + "chart": 192, + "image_dimension": 2, + "rank": 2, + "support": "0x80004000000000000", + "support_size": 2 + }, + { + "chart": 193, + "image_dimension": 2, + "rank": 2, + "support": "0x81000000000000000", + "support_size": 2 + }, + { + "chart": 194, + "image_dimension": 2, + "rank": 2, + "support": "0x2400", + "support_size": 2 + }, + { + "chart": 195, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000000000000000000400", + "support_size": 2 + }, + { + "chart": 196, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000000000000000400", + "support_size": 2 + }, + { + "chart": 197, + "image_dimension": 2, + "rank": 2, + "support": "0x100000000000000000000002000", + "support_size": 2 + }, + { + "chart": 198, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000000000000002000", + "support_size": 2 + }, + { + "chart": 199, + "image_dimension": 2, + "rank": 2, + "support": "0x900000000000000000000000000", + "support_size": 2 + }, + { + "chart": 200, + "image_dimension": 2, + "rank": 2, + "support": "0x500000000", + "support_size": 2 + }, + { + "chart": 201, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000100000000", + "support_size": 2 + }, + { + "chart": 202, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000100000000", + "support_size": 2 + }, + { + "chart": 203, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000400000000", + "support_size": 2 + }, + { + "chart": 204, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000400000000", + "support_size": 2 + }, + { + "chart": 205, + "image_dimension": 2, + "rank": 2, + "support": "0x2800000000000000000000", + "support_size": 2 + }, + { + "chart": 206, + "image_dimension": 2, + "rank": 2, + "support": "0x48000000000", + "support_size": 2 + }, + { + "chart": 207, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000008000000000", + "support_size": 2 + }, + { + "chart": 208, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000008000000000", + "support_size": 2 + }, + { + "chart": 209, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000040000000000", + "support_size": 2 + }, + { + "chart": 210, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000040000000000", + "support_size": 2 + }, + { + "chart": 211, + "image_dimension": 2, + "rank": 2, + "support": "0x90000000000000000000", + "support_size": 2 + }, + { + "chart": 212, + "image_dimension": 2, + "rank": 2, + "support": "0x82", + "support_size": 2 + }, + { + "chart": 213, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000000000000000000002", + "support_size": 2 + }, + { + "chart": 214, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000000000000000000002", + "support_size": 2 + }, + { + "chart": 215, + "image_dimension": 2, + "rank": 2, + "support": "0x400000000000000000000000080", + "support_size": 2 + }, + { + "chart": 216, + "image_dimension": 2, + "rank": 2, + "support": "0x1000000000000000000000000080", + "support_size": 2 + }, + { + "chart": 217, + "image_dimension": 2, + "rank": 2, + "support": "0x1400000000000000000000000000", + "support_size": 2 + }, + { + "chart": 218, + "image_dimension": 2, + "rank": 2, + "support": "0x21000000", + "support_size": 2 + }, + { + "chart": 219, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000000000000001000000", + "support_size": 2 + }, + { + "chart": 220, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000000000000001000000", + "support_size": 2 + }, + { + "chart": 221, + "image_dimension": 2, + "rank": 2, + "support": "0x8000000000000000020000000", + "support_size": 2 + }, + { + "chart": 222, + "image_dimension": 2, + "rank": 2, + "support": "0x20000000000000000020000000", + "support_size": 2 + }, + { + "chart": 223, + "image_dimension": 2, + "rank": 2, + "support": "0x28000000000000000000000000", + "support_size": 2 + }, + { + "chart": 224, + "image_dimension": 2, + "rank": 2, + "support": "0x12000000", + "support_size": 2 + }, + { + "chart": 225, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000000000002000000", + "support_size": 2 + }, + { + "chart": 226, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000000000000002000000", + "support_size": 2 + }, + { + "chart": 227, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000000000010000000", + "support_size": 2 + }, + { + "chart": 228, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000000000000010000000", + "support_size": 2 + }, + { + "chart": 229, + "image_dimension": 2, + "rank": 2, + "support": "0x14000000000000000000000000", + "support_size": 2 + }, + { + "chart": 230, + "image_dimension": 2, + "rank": 2, + "support": "0x14", + "support_size": 2 + }, + { + "chart": 231, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000000000000000000004", + "support_size": 2 + }, + { + "chart": 232, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000000000000000004", + "support_size": 2 + }, + { + "chart": 233, + "image_dimension": 2, + "rank": 2, + "support": "0x80000000000000000000000010", + "support_size": 2 + }, + { + "chart": 234, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000000000000000000000010", + "support_size": 2 + }, + { + "chart": 235, + "image_dimension": 2, + "rank": 2, + "support": "0x2080000000000000000000000000", + "support_size": 2 + }, + { + "chart": 236, + "image_dimension": 2, + "rank": 2, + "support": "0x104000", + "support_size": 2 + }, + { + "chart": 237, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000000000000004000", + "support_size": 2 + }, + { + "chart": 238, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000000000004000", + "support_size": 2 + }, + { + "chart": 239, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000000000000100000", + "support_size": 2 + }, + { + "chart": 240, + "image_dimension": 2, + "rank": 2, + "support": "0x800000000000000000100000", + "support_size": 2 + }, + { + "chart": 241, + "image_dimension": 2, + "rank": 2, + "support": "0x840000000000000000000000", + "support_size": 2 + }, + { + "chart": 242, + "image_dimension": 2, + "rank": 2, + "support": "0x50000", + "support_size": 2 + }, + { + "chart": 243, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000000000000010000", + "support_size": 2 + }, + { + "chart": 244, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000000000000010000", + "support_size": 2 + }, + { + "chart": 245, + "image_dimension": 2, + "rank": 2, + "support": "0x10000000000000000040000", + "support_size": 2 + }, + { + "chart": 246, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000000000000040000", + "support_size": 2 + }, + { + "chart": 247, + "image_dimension": 2, + "rank": 2, + "support": "0x210000000000000000000000", + "support_size": 2 + }, + { + "chart": 248, + "image_dimension": 2, + "rank": 2, + "support": "0x1100", + "support_size": 2 + }, + { + "chart": 249, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000000000000000000100", + "support_size": 2 + }, + { + "chart": 250, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000000000000000000100", + "support_size": 2 + }, + { + "chart": 251, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000000000000000001000", + "support_size": 2 + }, + { + "chart": 252, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000000000000000001000", + "support_size": 2 + }, + { + "chart": 253, + "image_dimension": 2, + "rank": 2, + "support": "0x4200000000000000000000000000", + "support_size": 2 + }, + { + "chart": 254, + "image_dimension": 2, + "rank": 2, + "support": "0x2080000000", + "support_size": 2 + }, + { + "chart": 255, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000000080000000", + "support_size": 2 + }, + { + "chart": 256, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000000080000000", + "support_size": 2 + }, + { + "chart": 257, + "image_dimension": 2, + "rank": 2, + "support": "0x200000000002000000000", + "support_size": 2 + }, + { + "chart": 258, + "image_dimension": 2, + "rank": 2, + "support": "0x4000000000002000000000", + "support_size": 2 + }, + { + "chart": 259, + "image_dimension": 2, + "rank": 2, + "support": "0x4200000000000000000000", + "support_size": 2 + }, + { + "chart": 260, + "image_dimension": 2, + "rank": 2, + "support": "0x210000000000", + "support_size": 2 + }, + { + "chart": 261, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000010000000000", + "support_size": 2 + }, + { + "chart": 262, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000010000000000", + "support_size": 2 + }, + { + "chart": 263, + "image_dimension": 2, + "rank": 2, + "support": "0x2000000200000000000", + "support_size": 2 + }, + { + "chart": 264, + "image_dimension": 2, + "rank": 2, + "support": "0x40000000200000000000", + "support_size": 2 + }, + { + "chart": 265, + "image_dimension": 2, + "rank": 2, + "support": "0x42000000000000000000", + "support_size": 2 + }, + { + "chart": 266, + "image_dimension": 6, + "rank": 4, + "support": "0x3f96", + "support_size": 10 + }, + { + "chart": 267, + "image_dimension": 6, + "rank": 4, + "support": "0xcf1800000000000209", + "support_size": 11 + }, + { + "chart": 268, + "image_dimension": 6, + "rank": 4, + "support": "0x294f0841", + "support_size": 11 + }, + { + "chart": 269, + "image_dimension": 6, + "rank": 4, + "support": "0x5798000000000000000048", + "support_size": 10 + }, + { + "chart": 270, + "image_dimension": 6, + "rank": 4, + "support": "0x16b0c241", + "support_size": 11 + }, + { + "chart": 271, + "image_dimension": 6, + "rank": 4, + "support": "0xa866000000000000000a48", + "support_size": 11 + }, + { + "chart": 272, + "image_dimension": 6, + "rank": 4, + "support": "0x294f00000021", + "support_size": 10 + }, + { + "chart": 273, + "image_dimension": 6, + "rank": 4, + "support": "0x55cc0000000000000000000828", + "support_size": 11 + }, + { + "chart": 274, + "image_dimension": 6, + "rank": 4, + "support": "0x16b0c0000a21", + "support_size": 12 + }, + { + "chart": 275, + "image_dimension": 6, + "rank": 4, + "support": "0x2a330000000000000000000228", + "support_size": 10 + }, + { + "chart": 276, + "image_dimension": 6, + "rank": 4, + "support": "0x2ae000000000860", + "support_size": 9 + }, + { + "chart": 277, + "image_dimension": 6, + "rank": 4, + "support": "0x7f80000000000000000000000069", + "support_size": 12 + }, + { + "chart": 278, + "image_dimension": 6, + "rank": 4, + "support": "0x3000000001e001e0000000000090", + "support_size": 12 + }, + { + "chart": 279, + "image_dimension": 6, + "rank": 4, + "support": "0x3000000000c4144000000003000", + "support_size": 10 + }, + { + "chart": 280, + "image_dimension": 6, + "rank": 4, + "support": "0x20501004100021008020000", + "support_size": 10 + }, + { + "chart": 281, + "image_dimension": 6, + "rank": 4, + "support": "0x8204010200100040081040000", + "support_size": 10 + }, + { + "chart": 282, + "image_dimension": 6, + "rank": 4, + "support": "0x40080840204040010404008000", + "support_size": 11 + }, + { + "chart": 283, + "image_dimension": 6, + "rank": 4, + "support": "0x4808005000040080202100000", + "support_size": 10 + }, + { + "chart": 284, + "image_dimension": 6, + "rank": 4, + "support": "0x10040020204100404810004000", + "support_size": 11 + }, + { + "chart": 285, + "image_dimension": 6, + "rank": 4, + "support": "0x1402003000100600100a00000", + "support_size": 11 + }, + { + "chart": 286, + "image_dimension": 6, + "rank": 4, + "support": "0x2001028100404040a020010000", + "support_size": 12 + }, + { + "chart": 287, + "image_dimension": 6, + "rank": 4, + "support": "0x2101008200040500040480000", + "support_size": 11 + }, + { + "chart": 288, + "image_dimension": 6, + "rank": 4, + "support": "0x48000000001480a400000000006", + "support_size": 10 + }, + { + "chart": 289, + "image_dimension": 6, + "rank": 4, + "support": "0x4800000001221200400000000500", + "support_size": 10 + }, + { + "chart": 290, + "image_dimension": 6, + "rank": 4, + "support": "0x4800000001c0610000000000090", + "support_size": 10 + }, + { + "chart": 291, + "image_dimension": 6, + "rank": 4, + "support": "0x4800000000c0a41a000000003000", + "support_size": 12 + }, + { + "chart": 292, + "image_dimension": 6, + "rank": 4, + "support": "0x8201008108401021020010000", + "support_size": 12 + }, + { + "chart": 293, + "image_dimension": 6, + "rank": 4, + "support": "0x20280002401040080480000", + "support_size": 10 + }, + { + "chart": 294, + "image_dimension": 6, + "rank": 4, + "support": "0x4802002008011010410004000", + "support_size": 11 + }, + { + "chart": 295, + "image_dimension": 6, + "rank": 4, + "support": "0x40080020102011080200a00000", + "support_size": 11 + }, + { + "chart": 296, + "image_dimension": 6, + "rank": 4, + "support": "0x1408004008400804804008000", + "support_size": 11 + }, + { + "chart": 297, + "image_dimension": 6, + "rank": 4, + "support": "0x10040840102400a00102100000", + "support_size": 12 + }, + { + "chart": 298, + "image_dimension": 6, + "rank": 4, + "support": "0x210401010801080a008020000", + "support_size": 12 + }, + { + "chart": 299, + "image_dimension": 6, + "rank": 4, + "support": "0x20010500002010900041040000", + "support_size": 11 + }, + { + "chart": 300, + "image_dimension": 6, + "rank": 4, + "support": "0x300000000002b005800000000006", + "support_size": 11 + }, + { + "chart": 301, + "image_dimension": 6, + "rank": 4, + "support": "0x3000000001108a1800000000500", + "support_size": 11 + }, + { + "chart": 302, + "image_dimension": 6, + "rank": 4, + "support": "0x10802100a0000042004200000", + "support_size": 10 + }, + { + "chart": 303, + "image_dimension": 6, + "rank": 4, + "support": "0x20c300000000000000000cc00082", + "support_size": 11 + }, + { + "chart": 304, + "image_dimension": 6, + "rank": 4, + "support": "0xa28480000000000000004851400", + "support_size": 12 + }, + { + "chart": 305, + "image_dimension": 6, + "rank": 4, + "support": "0x414121000000000000002120a100", + "support_size": 12 + }, + { + "chart": 306, + "image_dimension": 6, + "rank": 4, + "support": "0x14005a00000000000000002a8014", + "support_size": 12 + }, + { + "chart": 307, + "image_dimension": 6, + "rank": 4, + "support": "0x40404080041204008080808000", + "support_size": 12 + }, + { + "chart": 308, + "image_dimension": 6, + "rank": 4, + "support": "0x40404080a0204101010100000", + "support_size": 12 + }, + { + "chart": 309, + "image_dimension": 6, + "rank": 4, + "support": "0x2400003c00000000330000000084", + "support_size": 12 + }, + { + "chart": 310, + "image_dimension": 6, + "rank": 4, + "support": "0x4200008108000000120a00002400", + "support_size": 11 + }, + { + "chart": 311, + "image_dimension": 6, + "rank": 4, + "support": "0x900001424000000085040001100", + "support_size": 12 + }, + { + "chart": 312, + "image_dimension": 6, + "rank": 4, + "support": "0x108000014a000000001540000012", + "support_size": 12 + }, + { + "chart": 313, + "image_dimension": 6, + "rank": 4, + "support": "0x10801100041000020042004000", + "support_size": 10 + }, + { + "chart": 314, + "image_dimension": 6, + "rank": 4, + "support": "0x4040210400888008082004000", + "support_size": 12 + }, + { + "chart": 315, + "image_dimension": 6, + "rank": 4, + "support": "0x102040410028200408080000", + "support_size": 11 + }, + { + "chart": 316, + "image_dimension": 6, + "rank": 4, + "support": "0x8010004800828004201010000", + "support_size": 11 + }, + { + "chart": 317, + "image_dimension": 6, + "rank": 4, + "support": "0x20208020410082080820040000", + "support_size": 12 + }, + { + "chart": 318, + "image_dimension": 6, + "rank": 4, + "support": "0x2020802800882010100420000", + "support_size": 12 + }, + { + "chart": 319, + "image_dimension": 6, + "rank": 4, + "support": "0x10804080810022042010100000", + "support_size": 12 + }, + { + "chart": 320, + "image_dimension": 6, + "rank": 4, + "support": "0xa14120000000000000008506100", + "support_size": 12 + }, + { + "chart": 321, + "image_dimension": 6, + "rank": 4, + "support": "0x41028400000000000000120a1400", + "support_size": 11 + }, + { + "chart": 322, + "image_dimension": 6, + "rank": 4, + "support": "0x108000c2000000000cc000000084", + "support_size": 11 + }, + { + "chart": 323, + "image_dimension": 6, + "rank": 4, + "support": "0x24000000b4000000002a80000012", + "support_size": 12 + }, + { + "chart": 324, + "image_dimension": 6, + "rank": 4, + "support": "0x8010802060004200420040000", + "support_size": 11 + }, + { + "chart": 325, + "image_dimension": 6, + "rank": 4, + "support": "0x20202040081200010101010000", + "support_size": 11 + }, + { + "chart": 326, + "image_dimension": 3, + "rank": 6, + "support": "0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fff800000000003d96", + "support_size": 24 + }, + { + "chart": 327, + "image_dimension": 3, + "rank": 6, + "support": "0x579930e0000000294f0049", + "support_size": 25 + }, + { + "chart": 328, + "image_dimension": 3, + "rank": 6, + "support": "0xa866000000000016b0c240", + "support_size": 17 + }, + { + "chart": 329, + "image_dimension": 3, + "rank": 6, + "support": "0x4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055cc000130e000294f00000021", + "support_size": 25 + }, + { + "chart": 330, + "image_dimension": 3, + "rank": 6, + "support": "0x800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a33000000000016b0c0000228", + "support_size": 19 + }, + { + "chart": 331, + "image_dimension": 3, + "rank": 6, + "support": "0x7f8000000130e2ae000000000809", + "support_size": 23 + }, + { + "chart": 332, + "image_dimension": 3, + "rank": 6, + "support": "0x3300000001fca0a4000000003899", + "support_size": 23 + }, + { + "chart": 333, + "image_dimension": 3, + "rank": 6, + "support": "0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000822451010e100061089060809", + "support_size": 24 + }, + { + "chart": 334, + "image_dimension": 3, + "rank": 6, + "support": "0x2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004488884510a040090606108801", + "support_size": 24 + }, + { + "chart": 335, + "image_dimension": 3, + "rank": 6, + "support": "0x11442023000100204910a04000", + "support_size": 17 + }, + { + "chart": 336, + "image_dimension": 3, + "rank": 6, + "support": "0x2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002211128900404050a060490008", + "support_size": 22 + }, + { + "chart": 337, + "image_dimension": 3, + "rank": 6, + "support": "0x4c8000000133fa0a000000000d0f", + "support_size": 24 + }, + { + "chart": 338, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004c80000001fca61a000000003899", + "support_size": 26 + }, + { + "chart": 339, + "image_dimension": 3, + "rank": 6, + "support": "0x82212893064010610a0490809", + "support_size": 25 + }, + { + "chart": 340, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044882022106000090610a04000", + "support_size": 19 + }, + { + "chart": 341, + "image_dimension": 3, + "rank": 6, + "support": "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011448844002000204906108000", + "support_size": 18 + }, + { + "chart": 342, + "image_dimension": 3, + "rank": 6, + "support": "0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002211451120c00010a049060809", + "support_size": 24 + }, + { + "chart": 343, + "image_dimension": 3, + "rank": 6, + "support": "0x330000000123f8a5800000000d0f", + "support_size": 25 + }, + { + "chart": 344, + "image_dimension": 3, + "rank": 6, + "support": "0x2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007ffc000000037d6", + "support_size": 24 + }, + { + "chart": 345, + "image_dimension": 3, + "rank": 6, + "support": "0x2a335798000551c00000000068", + "support_size": 25 + }, + { + "chart": 346, + "image_dimension": 3, + "rank": 6, + "support": "0x55cca866000000000000000808", + "support_size": 17 + }, + { + "chart": 347, + "image_dimension": 3, + "rank": 6, + "support": "0x550e94f16b0c020", + "support_size": 23 + }, + { + "chart": 348, + "image_dimension": 3, + "rank": 6, + "support": "0x551d6b0e94f0861", + "support_size": 27 + }, + { + "chart": 349, + "image_dimension": 3, + "rank": 6, + "support": "0x7f80000000cf1801000000000200", + "support_size": 18 + }, + { + "chart": 350, + "image_dimension": 3, + "rank": 6, + "support": "0x7800000000e213e0000000000590", + "support_size": 18 + }, + { + "chart": 351, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002003078100455182b028030240", + "support_size": 26 + }, + { + "chart": 352, + "image_dimension": 3, + "rank": 6, + "support": "0x4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500c0860000140414c1400c020", + "support_size": 20 + }, + { + "chart": 353, + "image_dimension": 3, + "rank": 6, + "support": "0x5c0a006000551e80302b00260", + "support_size": 26 + }, + { + "chart": 354, + "image_dimension": 3, + "rank": 6, + "support": "0xa3050182005119400c14c0260", + "support_size": 25 + }, + { + "chart": 355, + "image_dimension": 3, + "rank": 6, + "support": "0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007800000000d4d1fc00000003266", + "support_size": 26 + }, + { + "chart": 356, + "image_dimension": 3, + "rank": 6, + "support": "0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007800000001d0ff00000000007f0", + "support_size": 24 + }, + { + "chart": 357, + "image_dimension": 3, + "rank": 6, + "support": "0x200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a305018000010c2b028030000", + "support_size": 20 + }, + { + "chart": 358, + "image_dimension": 3, + "rank": 6, + "support": "0x5c0a006008551c14c1400c260", + "support_size": 27 + }, + { + "chart": 359, + "image_dimension": 3, + "rank": 6, + "support": "0x500c0860100411a80302b00000", + "support_size": 20 + }, + { + "chart": 360, + "image_dimension": 3, + "rank": 6, + "support": "0x20030780000150d400c14c0260", + "support_size": 23 + }, + { + "chart": 361, + "image_dimension": 3, + "rank": 6, + "support": "0x7800000000c2b15fc00000003266", + "support_size": 26 + }, + { + "chart": 362, + "image_dimension": 3, + "rank": 6, + "support": "0x54c413108b0088143000200828", + "support_size": 24 + }, + { + "chart": 363, + "image_dimension": 3, + "rank": 6, + "support": "0x208240310381018870110c600082", + "support_size": 25 + }, + { + "chart": 364, + "image_dimension": 3, + "rank": 6, + "support": "0xa28080120102011080200851400", + "support_size": 18 + }, + { + "chart": 365, + "image_dimension": 3, + "rank": 6, + "support": "0x414121910481848890582120a100", + "support_size": 27 + }, + { + "chart": 366, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001440521840a140c81114042a0014", + "support_size": 27 + }, + { + "chart": 367, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040004080041204008096b0c241", + "support_size": 21 + }, + { + "chart": 368, + "image_dimension": 3, + "rank": 6, + "support": "0x444453908b028c101010300048", + "support_size": 25 + }, + { + "chart": 369, + "image_dimension": 3, + "rank": 6, + "support": "0x2440422d0181418823100c220084", + "support_size": 26 + }, + { + "chart": 370, + "image_dimension": 3, + "rank": 6, + "support": "0x4248608108918489120a24212400", + "support_size": 27 + }, + { + "chart": 371, + "image_dimension": 3, + "rank": 6, + "support": "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000920010524002018984041041100", + "support_size": 21 + }, + { + "chart": 372, + "image_dimension": 3, + "rank": 6, + "support": "0x1082101042200040500504480012", + "support_size": 18 + }, + { + "chart": 373, + "image_dimension": 3, + "rank": 6, + "support": "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050c0100085108014b086204a21", + "support_size": 25 + }, + { + "chart": 374, + "image_dimension": 4, + "rank": 6, + "support": "0x4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040402104e1808008082004209", + "support_size": 19 + }, + { + "chart": 375, + "image_dimension": 3, + "rank": 6, + "support": "0x304050314120014830140c280090", + "support_size": 24 + }, + { + "chart": 376, + "image_dimension": 3, + "rank": 6, + "support": "0x308011004910089804201010500", + "support_size": 19 + }, + { + "chart": 377, + "image_dimension": 3, + "rank": 6, + "support": "0x486060912081a498181824243000", + "support_size": 28 + }, + { + "chart": 378, + "image_dimension": 3, + "rank": 6, + "support": "0x4c2420902814802511104620006", + "support_size": 25 + }, + { + "chart": 379, + "image_dimension": 3, + "rank": 6, + "support": "0x50c0518081022e143014300860", + "support_size": 26 + }, + { + "chart": 380, + "image_dimension": 3, + "rank": 6, + "support": "0x2a230802800882010300000228", + "support_size": 18 + }, + { + "chart": 381, + "image_dimension": 3, + "rank": 6, + "support": "0x40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020c300401018901480e20cc00082", + "support_size": 25 + }, + { + "chart": 382, + "image_dimension": 3, + "rank": 6, + "support": "0x4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a14108521004100021000526100", + "support_size": 21 + }, + { + "chart": 383, + "image_dimension": 3, + "rank": 6, + "support": "0x4100949028281044504252021400", + "support_size": 24 + }, + { + "chart": 384, + "image_dimension": 3, + "rank": 6, + "support": "0x14005a82a0083405044080688014", + "support_size": 25 + }, + { + "chart": 385, + "image_dimension": 3, + "rank": 6, + "support": "0xa06049102c2046290d0841", + "support_size": 24 + }, + { + "chart": 386, + "image_dimension": 3, + "rank": 6, + "support": "0x811a84688182c004001430a48", + "support_size": 25 + }, + { + "chart": 387, + "image_dimension": 3, + "rank": 6, + "support": "0x10c018c22010301504c200e20084", + "support_size": 25 + }, + { + "chart": 388, + "image_dimension": 3, + "rank": 6, + "support": "0x904801405000040081042101100", + "support_size": 16 + }, + { + "chart": 389, + "image_dimension": 3, + "rank": 6, + "support": "0x4210148128285104520210426400", + "support_size": 25 + }, + { + "chart": 390, + "image_dimension": 3, + "rank": 6, + "support": "0x2401508090089404806284428012", + "support_size": 24 + }, + { + "chart": 391, + "image_dimension": 3, + "rank": 6, + "support": "0x20208020490082290d20040021", + "support_size": 19 + }, + { + "chart": 392, + "image_dimension": 3, + "rank": 6, + "support": "0x8118822c71800204620460209", + "support_size": 25 + }, + { + "chart": 393, + "image_dimension": 3, + "rank": 6, + "support": "0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004c0404080181414008080808090", + "support_size": 19 + }, + { + "chart": 394, + "image_dimension": 3, + "rank": 6, + "support": "0x4804040409201200501010100500", + "support_size": 17 + }, + { + "chart": 395, + "image_dimension": 3, + "rank": 6, + "support": "0x3109091200c5144024242427000", + "support_size": 26 + }, + { + "chart": 396, + "image_dimension": 3, + "rank": 6, + "support": "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030011882300aa005846204620006", + "support_size": 27 + }, + { + "chart": 397, + "image_dimension": 3, + "rank": 6, + "support": "0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002030a0600012aa014301430860", + "support_size": 25 + }, + { + "chart": 398, + "image_dimension": 3, + "rank": 6, + "support": "0x55cc4488441a260280c0008828", + "support_size": 28 + }, + { + "chart": 399, + "image_dimension": 3, + "rank": 6, + "support": "0x2083000840204040010408c08082", + "support_size": 17 + }, + { + "chart": 400, + "image_dimension": 3, + "rank": 6, + "support": "0xa2848840c408c22824844051400", + "support_size": 26 + }, + { + "chart": 401, + "image_dimension": 3, + "rank": 6, + "support": "0x410129002010201108022180a100", + "support_size": 19 + }, + { + "chart": 402, + "image_dimension": 3, + "rank": 6, + "support": "0x14011a240b4009226201408a8014", + "support_size": 27 + }, + { + "chart": 403, + "image_dimension": 3, + "rank": 6, + "support": "0x10006184a0822062056b04241", + "support_size": 25 + }, + { + "chart": 404, + "image_dimension": 3, + "rank": 6, + "support": "0x1188469844182202004280c048", + "support_size": 24 + }, + { + "chart": 405, + "image_dimension": 3, + "rank": 6, + "support": "0x2403183c00600860710040c88084", + "support_size": 26 + }, + { + "chart": 406, + "image_dimension": 3, + "rank": 6, + "support": "0x4220018400002012800a41042400", + "support_size": 17 + }, + { + "chart": 407, + "image_dimension": 3, + "rank": 6, + "support": "0x909281024508c230a5060819100", + "support_size": 28 + }, + { + "chart": 408, + "image_dimension": 3, + "rank": 6, + "support": "0x108002014b404100001548020012", + "support_size": 19 + }, + { + "chart": 409, + "image_dimension": 3, + "rank": 6, + "support": "0x50c04080a0a2606a0d0908a21", + "support_size": 27 + }, + { + "chart": 410, + "image_dimension": 3, + "rank": 6, + "support": "0x118844884e1820062010908209", + "support_size": 25 + }, + { + "chart": 411, + "image_dimension": 3, + "rank": 6, + "support": "0x300202080ba001c0010100420090", + "support_size": 19 + }, + { + "chart": 412, + "image_dimension": 3, + "rank": 6, + "support": "0x320208020500003880860040500", + "support_size": 18 + }, + { + "chart": 413, + "image_dimension": 3, + "rank": 6, + "support": "0x480909040cc0ac3a02424181b000", + "support_size": 29 + }, + { + "chart": 414, + "image_dimension": 3, + "rank": 6, + "support": "0x481182448414828620448888006", + "support_size": 26 + }, + { + "chart": 415, + "image_dimension": 3, + "rank": 6, + "support": "0x50c06104002060280c280c860", + "support_size": 22 + }, + { + "chart": 416, + "image_dimension": 3, + "rank": 6, + "support": "0x200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028332044470228280c08000228", + "support_size": 25 + }, + { + "chart": 417, + "image_dimension": 3, + "rank": 6, + "support": "0x20c30002840626010c088cc80082", + "support_size": 25 + }, + { + "chart": 418, + "image_dimension": 3, + "rank": 6, + "support": "0x200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a16021008200040500048186100", + "support_size": 20 + }, + { + "chart": 419, + "image_dimension": 3, + "rank": 6, + "support": "0x4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041028605050643000a181a081400", + "support_size": 26 + }, + { + "chart": 420, + "image_dimension": 3, + "rank": 6, + "support": "0x14005a401416821088a8082a8014", + "support_size": 27 + }, + { + "chart": 421, + "image_dimension": 3, + "rank": 6, + "support": "0x8028008820101294f0841", + "support_size": 19 + }, + { + "chart": 422, + "image_dimension": 3, + "rank": 6, + "support": "0x222228464702820800280c0a48", + "support_size": 25 + }, + { + "chart": 423, + "image_dimension": 3, + "rank": 6, + "support": "0x108342c2040686008cc00c088084", + "support_size": 26 + }, + { + "chart": 424, + "image_dimension": 3, + "rank": 6, + "support": "0x800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000912061420264300485858085100", + "support_size": 28 + }, + { + "chart": 425, + "image_dimension": 3, + "rank": 6, + "support": "0x420680810d0602401a0a0a182400", + "support_size": 25 + }, + { + "chart": 426, + "image_dimension": 3, + "rank": 6, + "support": "0x24400a0094102011002880a00012", + "support_size": 19 + }, + { + "chart": 427, + "image_dimension": 3, + "rank": 6, + "support": "0x800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008010000800828210d01010021", + "support_size": 16 + }, + { + "chart": 428, + "image_dimension": 3, + "rank": 6, + "support": "0x22222044c91a00090909090209", + "support_size": 25 + }, + { + "chart": 429, + "image_dimension": 3, + "rank": 6, + "support": "0x4830a02141406100c280c280090", + "support_size": 24 + }, + { + "chart": 430, + "image_dimension": 3, + "rank": 6, + "support": "0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000048128211052212004a084a084500", + "support_size": 26 + }, + { + "chart": 431, + "image_dimension": 3, + "rank": 6, + "support": "0x304040408084144101010103000", + "support_size": 17 + }, + { + "chart": 432, + "image_dimension": 3, + "rank": 6, + "support": "0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000304040408006a201808080808006", + "support_size": 20 + }, + { + "chart": 433, + "image_dimension": 3, + "rank": 6, + "support": "0x200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a0308060200ae280c280c0860", + "support_size": 25 + }, + { + "chart": 434, + "image_dimension": 3, + "rank": 6, + "support": "0x3d800056660000002970c0000069", + "support_size": 26 + }, + { + "chart": 435, + "image_dimension": 3, + "rank": 6, + "support": "0x4a14120242c0a41a212088507100", + "support_size": 29 + }, + { + "chart": 436, + "image_dimension": 3, + "rank": 6, + "support": "0x42412142420c41442120a1209100", + "support_size": 26 + }, + { + "chart": 437, + "image_dimension": 3, + "rank": 6, + "support": "0x228484241221200612084850100", + "support_size": 23 + }, + { + "chart": 438, + "image_dimension": 3, + "rank": 6, + "support": "0x41028400021108a18000120a1400", + "support_size": 19 + }, + { + "chart": 439, + "image_dimension": 3, + "rank": 6, + "support": "0xc108000000120a00002e96", + "support_size": 16 + }, + { + "chart": 440, + "image_dimension": 3, + "rank": 6, + "support": "0x660000d664000000332080001bcc", + "support_size": 26 + }, + { + "chart": 441, + "image_dimension": 3, + "rank": 6, + "support": "0x4900042418039210018084000", + "support_size": 18 + }, + { + "chart": 442, + "image_dimension": 3, + "rank": 6, + "support": "0x4248094a422640440124a4048100", + "support_size": 26 + }, + { + "chart": 443, + "image_dimension": 3, + "rank": 6, + "support": "0x4221606243081300612181a11100", + "support_size": 28 + }, + { + "chart": 444, + "image_dimension": 3, + "rank": 6, + "support": "0x12060802902c82810102521000", + "support_size": 21 + }, + { + "chart": 445, + "image_dimension": 3, + "rank": 6, + "support": "0x528000434a000000297ac0001133", + "support_size": 26 + }, + { + "chart": 446, + "image_dimension": 3, + "rank": 6, + "support": "0x660000156e000000212a8000115a", + "support_size": 24 + }, + { + "chart": 447, + "image_dimension": 3, + "rank": 6, + "support": "0x210824200812423002090580000", + "support_size": 19 + }, + { + "chart": 448, + "image_dimension": 3, + "rank": 6, + "support": "0x42092800522a0100252085241100", + "support_size": 24 + }, + { + "chart": 449, + "image_dimension": 3, + "rank": 6, + "support": "0x6041028104524440a020818000", + "support_size": 20 + }, + { + "chart": 450, + "image_dimension": 3, + "rank": 6, + "support": "0x4206144252508898a1a08a025100", + "support_size": 30 + }, + { + "chart": 451, + "image_dimension": 3, + "rank": 6, + "support": "0x50800080420000003ff040001ba5", + "support_size": 25 + }, + { + "chart": 452, + "image_dimension": 3, + "rank": 6, + "support": "0x4b00ff00000000000000003fc07d", + "support_size": 26 + }, + { + "chart": 453, + "image_dimension": 3, + "rank": 6, + "support": "0x3080a4c201e001e00cc000154094", + "support_size": 28 + }, + { + "chart": 454, + "image_dimension": 3, + "rank": 6, + "support": "0x2080a53c001c0610330000154004", + "support_size": 25 + }, + { + "chart": 455, + "image_dimension": 3, + "rank": 6, + "support": "0x200001014a02b005801540000004", + "support_size": 18 + }, + { + "chart": 456, + "image_dimension": 3, + "rank": 6, + "support": "0x4800000b401480a402a80000006", + "support_size": 18 + }, + { + "chart": 457, + "image_dimension": 3, + "rank": 6, + "support": "0x43a5000000000000000cd57f14", + "support_size": 23 + }, + { + "chart": 458, + "image_dimension": 3, + "rank": 6, + "support": "0x2a027b0000000000000004801628", + "support_size": 17 + }, + { + "chart": 459, + "image_dimension": 3, + "rank": 6, + "support": "0xa0a582a14140c248a820154014", + "support_size": 29 + }, + { + "chart": 460, + "image_dimension": 3, + "rank": 6, + "support": "0x2088a5180a168405221420154014", + "support_size": 29 + }, + { + "chart": 461, + "image_dimension": 3, + "rank": 6, + "support": "0x202540083210910140010000", + "support_size": 16 + }, + { + "chart": 462, + "image_dimension": 3, + "rank": 6, + "support": "0x2088a44014a00928044281144014", + "support_size": 25 + }, + { + "chart": 463, + "image_dimension": 3, + "rank": 6, + "support": "0x61c1a500000000000000087be955", + "support_size": 26 + }, + { + "chart": 464, + "image_dimension": 3, + "rank": 6, + "support": "0x2ac1ff000000000000000845293c", + "support_size": 25 + }, + { + "chart": 465, + "image_dimension": 3, + "rank": 6, + "support": "0x108040a0a14122446810104000", + "support_size": 20 + }, + { + "chart": 466, + "image_dimension": 3, + "rank": 6, + "support": "0x2080a5240a0a8215111400154014", + "support_size": 27 + }, + { + "chart": 467, + "image_dimension": 3, + "rank": 6, + "support": "0x2090251940143400a20142150014", + "support_size": 26 + }, + { + "chart": 468, + "image_dimension": 3, + "rank": 6, + "support": "0x2084a582154008c8088282154014", + "support_size": 28 + }, + { + "chart": 469, + "image_dimension": 3, + "rank": 6, + "support": "0x4102840000000000000004bad641", + "support_size": 18 + }, + { + "chart": 470, + "image_dimension": 3, + "rank": 6, + "support": "0x5f4b00000000000000000cc000eb", + "support_size": 20 + }, + { + "chart": 471, + "image_dimension": 3, + "rank": 6, + "support": "0x34340000b5e001e0002ab3000092", + "support_size": 29 + }, + { + "chart": 472, + "image_dimension": 3, + "rank": 6, + "support": "0x143c00014a1c0610001573000082", + "support_size": 26 + }, + { + "chart": 473, + "image_dimension": 3, + "rank": 6, + "support": "0x143c003c0002b005b30031000000", + "support_size": 24 + }, + { + "chart": 474, + "image_dimension": 3, + "rank": 6, + "support": "0x4bc00c20001480a4cc033000006", + "support_size": 25 + }, + { + "chart": 475, + "image_dimension": 3, + "rank": 6, + "support": "0x5a00000000000000022abf96", + "support_size": 19 + }, + { + "chart": 476, + "image_dimension": 3, + "rank": 6, + "support": "0x557f4800000000000000310a1caa", + "support_size": 25 + }, + { + "chart": 477, + "image_dimension": 3, + "rank": 6, + "support": "0x142c80c0858100620c2223100082", + "support_size": 26 + }, + { + "chart": 478, + "image_dimension": 3, + "rank": 6, + "support": "0x4000c481a2604b01110000000", + "support_size": 18 + }, + { + "chart": 479, + "image_dimension": 3, + "rank": 6, + "support": "0x103c003102049011030461000082", + "support_size": 22 + }, + { + "chart": 480, + "image_dimension": 3, + "rank": 6, + "support": "0x143c04023060498840c8b3004082", + "support_size": 29 + }, + { + "chart": 481, + "image_dimension": 3, + "rank": 6, + "support": "0xe0012000000000000001ef0e341", + "support_size": 20 + }, + { + "chart": 482, + "image_dimension": 3, + "rank": 6, + "support": "0x557f33000000000000003320a3aa", + "support_size": 28 + }, + { + "chart": 483, + "image_dimension": 3, + "rank": 6, + "support": "0x20c0306101820c0880040080", + "support_size": 17 + }, + { + "chart": 484, + "image_dimension": 3, + "rank": 6, + "support": "0x143c000d02062014b00473000002", + "support_size": 25 + }, + { + "chart": 485, + "image_dimension": 3, + "rank": 6, + "support": "0x3048189601031120000000", + "support_size": 16 + }, + { + "chart": 486, + "image_dimension": 3, + "rank": 6, + "support": "0x141c01028580486840e213010082", + "support_size": 27 + }, + { + "chart": 487, + "image_dimension": 3, + "rank": 6, + "support": "0x1e3c48000000000000003fcf1cc3", + "support_size": 29 + }, + { + "chart": 488, + "image_dimension": 3, + "rank": 6, + "support": "0x768000a998000000128f00002469", + "support_size": 26 + }, + { + "chart": 489, + "image_dimension": 3, + "rank": 6, + "support": "0x802842890c0a41a0481120a2000", + "support_size": 24 + }, + { + "chart": 490, + "image_dimension": 3, + "rank": 6, + "support": "0x9284800000c4144040004852400", + "support_size": 19 + }, + { + "chart": 491, + "image_dimension": 3, + "rank": 6, + "support": "0x841210001221200400421208400", + "support_size": 17 + }, + { + "chart": 492, + "image_dimension": 3, + "rank": 6, + "support": "0x9141228901108a1848508506400", + "support_size": 27 + }, + { + "chart": 493, + "image_dimension": 3, + "rank": 6, + "support": "0x900003cb40000000cd540003b96", + "support_size": 27 + }, + { + "chart": 494, + "image_dimension": 3, + "rank": 6, + "support": "0x198000ff8800000008c5000020cc", + "support_size": 24 + }, + { + "chart": 495, + "image_dimension": 3, + "rank": 6, + "support": "0x912902880918032848518122400", + "support_size": 27 + }, + { + "chart": 496, + "image_dimension": 3, + "rank": 6, + "support": "0x921092a910a404040a524212400", + "support_size": 27 + }, + { + "chart": 497, + "image_dimension": 3, + "rank": 6, + "support": "0x48604010241304040081848400", + "support_size": 19 + }, + { + "chart": 498, + "image_dimension": 3, + "rank": 6, + "support": "0x904062890402c89040502486400", + "support_size": 25 + }, + { + "chart": 499, + "image_dimension": 3, + "rank": 6, + "support": "0x24000000a4000000123ac0000a33", + "support_size": 19 + }, + { + "chart": 500, + "image_dimension": 3, + "rank": 6, + "support": "0x198000a9bc000000049540002e5a", + "support_size": 27 + }, + { + "chart": 501, + "image_dimension": 3, + "rank": 6, + "support": "0x10140040512428a0010a180000", + "support_size": 18 + }, + { + "chart": 502, + "image_dimension": 3, + "rank": 6, + "support": "0x909412093060104648120a42400", + "support_size": 26 + }, + { + "chart": 503, + "image_dimension": 3, + "rank": 6, + "support": "0x9602808d0285240058505018400", + "support_size": 26 + }, + { + "chart": 504, + "image_dimension": 3, + "rank": 6, + "support": "0x906822890808893048410426400", + "support_size": 26 + }, + { + "chart": 505, + "image_dimension": 3, + "rank": 6, + "support": "0x2400003c000000001a4a000020a5", + "support_size": 17 + }, + { + "chart": 506, + "image_dimension": 17, + "rank": 4, + "support": "0x300003e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000551c00000000260", + "support_size": 17 + }, + { + "chart": 507, + "image_dimension": 15, + "rank": 4, + "support": "0xfc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000130e000000000000809", + "support_size": 15 + }, + { + "chart": 508, + "image_dimension": 15, + "rank": 4, + "support": "0x3e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020004060200080808080000", + "support_size": 15 + }, + { + "chart": 509, + "image_dimension": 13, + "rank": 4, + "support": "0x1c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000108020081004004200420000", + "support_size": 13 + }, + { + "chart": 519, + "image_dimension": 12, + "rank": 4, + "support": "0x1080408400822020040808000", + "support_size": 12 + }, + { + "chart": 520, + "image_dimension": 14, + "rank": 4, + "support": "0xc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040401100810088101004200000", + "support_size": 14 + }, + { + "chart": 521, + "image_dimension": 12, + "rank": 4, + "support": "0x900002890000000048500002400", + "support_size": 12 + }, + { + "chart": 522, + "image_dimension": 12, + "rank": 4, + "support": "0x143c000000000000000033000082", + "support_size": 12 + }, + { + "chart": 523, + "image_dimension": 12, + "rank": 4, + "support": "0x2080a50000000000000000154014", + "support_size": 12 + }, + { + "chart": 524, + "image_dimension": 12, + "rank": 4, + "support": "0x4200004242000000212080001100", + "support_size": 12 + } + ], + "exact_cosets": 511, + "independent_paid_rows": 5742, + "inherited_replay": { + "all_donor_union_exclusions": 5733, + "arrivals": 5742, + "exceptional_pairs": 478764, + "exceptional_singletons": 4626 + }, + "original_source_attainments": 5742, + "paid_row_trace_sha256": "554c0964934f91d50e4ea15cbd033d29bf694431ce53b95f94606c7cfda276b0", + "quotient_rank": 135, + "quotient_unit_images_sha256": "5cd0b1b935ad36a6f8f67eb04fe8c5b313a9315dad6669bb2fea79bea2e110b3", + "rank_budget_bounds": [ + 0, + 1, + 2, + 3, + 17, + 18, + 30 + ], + "scope": "All direct bundles from fixed causal libraries attain the original price floor for 0 0`, +`Σ s_i^t = R^t Σ (s_i/R)^t ≥ R^t` for `0 < t <= 1`. +A strictly cheaper bundle must therefore have `R < r`. In particular, it +can use only individually lower-rank donors. If the row is outside the sum +of **all** these donor libraries and the destination library, every +strictly cheaper direct bundle is excluded, regardless of its size. + +For the cases where that sum contains the row, the verifier works in the +quotient by `V_d`. It tests every nonempty eligible singleton and every +distinct eligible pair with rank sum below `r`. The free destination +by itself is also checked. Empty libraries and repeated donors reduce to +these cases. In each test the projected row is outside the projected +donor span. Any bundle with rank sum at least `r` is already covered by the +price inequality. The original source row at the same deadline attains the +old price by the cited single-delivery result. + +## Finite evidence + +| Orientation | Arrivals | Excluded by the sum of all lower-rank donors | Exceptional singletons checked | Exceptional pairs checked | +| --- | ---: | ---: | ---: | ---: | +| Forward | 2,871 | 2,862 | 4,626 | 478,764 | +| Transpose | 2,871 | 2,871 | 0 | 0 | + +The nine exceptions are forward rank-seven arrivals into chart 0 from +charts 510 through 518, at every eighth event from 26861 through 26925. +Their full lower-rank donor sums contain the required rows. Each sum grants every eligible donor +simultaneously, with no total-rank constraint. The quotient check +enforces the rank-sum constraint for one or two paid donors. + +The replay authenticates the compressed native word, reconstructs the +chronological scalar rows, and computes rational nesting from the +chart bases and their orthogonal complements. For each arrival it +tests the donor span before adding that arrival to its destination +library. Its small control gives two donors that can reconstruct a +row together even though neither can do so alone. It also checks that +an equal-rank-sum pair is omitted from the strict budget test. + +## Scope + +The result covers fixed causal stocks and direct transfers of scalar XOR +forms into one original destination by its old deadline. The nine remaining +arrivals can still be tested with three or more positive-rank donors. +New charts, intermediate relays, changed helper relations, altered values +and deadlines, and adaptive changes to the libraries are outside the +contract. Storage and ordinary formation are granted, so the price floor +also holds for subclasses that charge nonnegative costs for them. + +Productive targets and the remaining caller terms are kept fixed. Replacing +a paid term within this contract cannot improve its signed margin. The +selected frontier and its five assumptions remain as recorded. Physical +compiler delivery, storage and restoration, tape movement, analytic recovery, +the selected cold replay, Lean and Docker were outside this proof. + +This changes the scope of `bit-helper-contract` to a paid-path relaxation of +the selected BIT supplier. [Task](TASK.json) · [Source pins](SOURCES.json) + +## Reproduce + +Use CPython 3.12.15 and its standard library from the repository root. + +```sh +python3.12 -B -W error -X dev research/bit-causal-multi-delivery/verify.py +python3.12 -B -W error -X dev -O research/bit-causal-multi-delivery/verify.py +python3.12 -B scripts/research_package.py --package research/bit-causal-multi-delivery +python3.12 -B scripts/check_research_commit.py --package research/bit-causal-multi-delivery --check-source-history +``` + +Both direct modes produce this marker. + +```text +PASS_BIT_CAUSAL_MULTI_DELIVERY arrivals=5742 union_excluded=5733 exceptional_singles=4626 exceptional_pairs=478764 +``` + +In a sparse checkout, materialize this package and `research/paired-query-only-bit`. +The direct checker needs the one [pinned native word](SOURCES.json), with no +Git or network calls. The publication preflight requires full Git history. + +## Open next questions + +- For the nine exceptions, can three or more direct deliveries beat the rank-seven + tariff? Start with the quotient at forward event 26861 and seek a donor subset + with total rank at most six. The full donor sum gives no such subset or price. +- Could a relay create a lower-cost arrival under a changed causal library? + Start with one exact intermediate chart and give its entry, delivery and + restoration costs. The fixed-library proof grants no relay information. + +## Credit + +This contribution was produced by Nick Petalas. Ali Romman supplied the +fixed-library model, its single-delivery floor and the multi-delivery +question in [PR #7723](https://github.com/aliromman/integer-mult-bounds/blob/a4fd22c08058c0fef830306b2d46e4a51f091939/research/bit-causal-delivery-rank-obstruction/README.md). +Jerry Chen / CubeJerry supplied the selected [PR #7001](https://github.com/CrocSwap/integer-mult-bounds/pull/7001) +caller. Credit zxv and the retained native authors for the exact word, +DreamingOfClouds for the chain-root caller, and ToikY for the related +fixed-destination and retag bounds. The original source notices remain +with the pinned input. New material is Apache-2.0. Independent human +and formal proof-kernel review are unclaimed. diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/bit-causal-multi-delivery/verify.py b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/bit-causal-multi-delivery/verify.py new file mode 100644 index 0000000000..5e26b8e918 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/bit-causal-multi-delivery/verify.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +"""Verify the fixed-library direct-delivery obstruction on the selected BIT word.""" + +from collections import Counter +from collections.abc import Iterable, Iterator +from dataclasses import dataclass +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations +from math import lcm +from pathlib import Path +import gzip +import json + +ROOT = Path(__file__).resolve().parents[2] +WORD = ROOT / "research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz" +WORD_SHA256 = "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78" +AMBIENT = 8 +CHARTS = 636 +PUBLIC = 659 +OWNED = 237 +STEPS = 34_137 + + +@dataclass(frozen=True) +class Arrival: + clock: int + source: int + destination: int + row: int + + +def require(ok: bool, problem: str) -> None: + if not ok: + raise ValueError(problem) + + +def integer_row(raw: list[int | str]) -> tuple[int, ...]: + require(len(raw) == AMBIENT, "frame row width") + rational = tuple(map(Fraction, raw)) + scale = lcm(*(x.denominator for x in rational)) + return tuple(int(x * scale) for x in rational) + + +def rational_rank(rows: list[tuple[int, ...]]) -> int: + basis: dict[int, tuple[Fraction, ...]] = {} + for row in rows: + value = list(map(Fraction, row)) + for pivot, donor in basis.items(): + if value[pivot]: + factor = value[pivot] + value = [a - factor * b for a, b in zip(value, donor, strict=True)] + for pivot, coefficient in enumerate(value): + if coefficient: + basis[pivot] = tuple(x / coefficient for x in value) + break + return len(basis) + + +def orthogonal(v: tuple[int, ...], w: tuple[int, ...]) -> bool: + return sum(a * b for a, b in zip(v, w, strict=True)) == 0 + + +def nested_donors(frames: dict) -> tuple[list[int], list[list[tuple[int, int]]]]: + require(len(frames) == CHARTS, "chart count") + dims, spans, complements = [], [], [] + for chart in range(CHARTS): + frame = frames[str(chart)] + dim = frame["dim"] + span = [integer_row(row) for row in frame["B"]] + complement = [integer_row(row) for row in frame["A"]] + require(len(span) == rational_rank(span) == dim, "frame basis") + require(len(complement) == rational_rank(complement) == AMBIENT - dim, + "complement basis") + require(all(orthogonal(v, a) for v in span for a in complement), + "complement orthogonality") + dims.append(dim) + spans.append(span) + complements.append(complement) + + containing = { + row: {i for i, comp in enumerate(complements) if all(orthogonal(row, a) for a in comp)} + for row in {v for span in spans for v in span} + } + donors: list[list[tuple[int, int]]] = [[] for _ in range(CHARTS)] + for small, span in enumerate(spans): + supersets = set.intersection(set(range(CHARTS)), *(containing[v] for v in span)) + for large in sorted(supersets): + rank = dims[large] - dims[small] + if small == large: + continue + require(rank > 0, "distinct frames with equal spans") + donors[small].append((large, rank)) + donors[large].append((small, rank)) + return dims, donors + + +def entrance(word: dict, reverse: bool) -> list[int]: + return word["final" if reverse else "start"] + + +def arrivals(word: dict, reverse: bool) -> Iterator[Arrival]: + charts: list[int | None] = entrance(word, reverse) + [None] * OWNED + rows = [1 << role for role in range(PUBLIC)] + [0] * OWNED + instructions = reversed(word["program"]) if reverse else word["program"] + for clock, (op, role, *args) in enumerate(instructions): + require(0 <= role < len(rows), "lane index") + if op == "MOVE": + source, destination = args[::-1] if reverse else args + require(charts[role] == source, "MOVE source chart") + yield Arrival(clock, source, destination, rows[role]) + charts[role] = destination + elif op == "ADD": + donor, chart = args + require(0 <= donor < len(rows) and donor != role, "ADD donor") + require(charts[role] == charts[donor] == chart, "ADD chart") + if reverse: + rows[donor] ^= rows[role] + else: + rows[role] ^= rows[donor] + elif op == "SWAP": + (other,) = args + require(0 <= other < len(rows) and other != role, "SWAP lane") + charts[role], charts[other] = charts[other], charts[role] + rows[role], rows[other] = rows[other], rows[role] + elif op in ("INIT", "CLEAR"): + (chart,) = args + require(role >= PUBLIC, "lifetime operation on public lane") + if (op == "INIT") != reverse: + require(charts[role] is None, "INIT on a live lane") + charts[role] = chart + else: + require(charts[role] == chart, "CLEAR chart") + charts[role] = None + rows[role] = 0 + else: + raise ValueError(f"unknown instruction {op!r}") + require(charts == entrance(word, not reverse) + [None] * OWNED, "exit charts") + + +def residue(row: int, basis: dict[int, int]) -> int: + # Each XOR clears the leading bit, so at most PUBLIC XORs are possible. + for _ in range(PUBLIC): + if not row: + return 0 + pivot = row.bit_length() - 1 + if pivot not in basis: + return row + row ^= basis[pivot] + require(row == 0, "row exceeds the public input width") + return row + + +def insert(row: int, basis: dict[int, int]) -> None: + remaining = residue(row, basis) + if remaining: + basis[remaining.bit_length() - 1] = remaining + + +def span_basis(rows: Iterable[int], initial: dict[int, int]) -> dict[int, int]: + basis = initial.copy() + for row in rows: + insert(row, basis) + return basis + + +def quotient(row: int, destination: list[tuple[int, int]]) -> int: + for pivot, donor in destination: + if row >> pivot & 1: + row ^= donor + return row + + +def affordable_bundles(donors: list[tuple[int, int]], old_rank: int) -> Iterator[tuple[int, ...]]: + for chart, rank in donors: + if rank < old_rank: + yield (chart,) + for (a, a_rank), (b, b_rank) in combinations(donors, 2): + if a_rank + b_rank < old_rank: + yield a, b + + +def check_small_bundles( + arrival: Arrival, old_rank: int, donors: list[tuple[int, int]], banks: list[dict[int, int]] +) -> Counter[int]: + destination = sorted(banks[arrival.destination].items(), reverse=True) + target = quotient(arrival.row, destination) + require(target != 0, f"destination alone at clock {arrival.clock}") + projected = { + chart: tuple(quotient(row, destination) for row in banks[chart].values()) + for chart, _ in donors + } + cases = Counter() + for bundle in affordable_bundles(donors, old_rank): + joined = span_basis((row for c in bundle for row in projected[c]), {}) + require(residue(target, joined) != 0, + f"cheaper bundle {bundle} at clock {arrival.clock}") + cases[len(bundle)] += 1 + return cases + + +def check_orientation( + word: dict, dims: list[int], donors: list[list[tuple[int, int]]], reverse: bool +) -> tuple[int, list[tuple[int, int, int, int]], Counter[int]]: + banks: list[dict[int, int]] = [{} for _ in range(CHARTS)] + for row, chart in enumerate(entrance(word, reverse)): + insert(1 << row, banks[chart]) + total = 0 + exceptions = [] + cases = Counter() + for arrival in arrivals(word, reverse): + old_rank = abs(dims[arrival.source] - dims[arrival.destination]) + require(old_rank > 0, "original MOVE rank") + eligible = [(chart, rank) for chart, rank in donors[arrival.destination] + if rank < old_rank and banks[chart]] + joined = span_basis( + (row for chart, _ in eligible for row in banks[chart].values()), + banks[arrival.destination], + ) + total += 1 + if residue(arrival.row, joined) == 0: + exceptions.append((arrival.clock, arrival.source, arrival.destination, old_rank)) + cases.update(check_small_bundles(arrival, old_rank, eligible, banks)) + # This arrival joins its chart's stock only after the test at its own deadline. + insert(arrival.row, banks[arrival.destination]) + return total, exceptions, cases + + +def check_controls() -> None: + # A common dual for individual donors need not exist. With free row 4, + # neither donor alone supplies 7, and rows 1 and 2 together do. + destination = {2: 4} + reduced_target = quotient(7, sorted(destination.items(), reverse=True)) + require(reduced_target == 3, "quotient control") + for row in (1, 2): + require(residue(reduced_target, span_basis((row,), {})) != 0, "single control") + require(residue(reduced_target, span_basis((1, 2), {})) == 0, "joint control") + ranks = [(10, 1), (20, 2), (30, 3)] + require(list(affordable_bundles(ranks, 3)) == [(10,), (20,)], "strict budget control") + require(list(affordable_bundles(ranks, 4)) == [(10,), (20,), (30,), (10, 20)], + "affordable pair control") + + +def main() -> None: + raw = WORD.read_bytes() + require(sha256(raw).hexdigest() == WORD_SHA256, "selected BIT word bytes") + word = json.loads(gzip.decompress(raw)) + require(word["public"] == PUBLIC and word["owned_fields"] == OWNED, "lane count") + require(len(word["program"]) == STEPS, "program length") + require(all(len(entrance(word, reverse)) == PUBLIC for reverse in (False, True)), + "entrance length") + check_controls() + dims, donors = nested_donors(word["frames"]) + forward = check_orientation(word, dims, donors, False) + transpose = check_orientation(word, dims, donors, True) + exceptions = [(26861 + 8 * i, 510 + i, 0, 7) for i in range(9)] + require(forward == (2871, exceptions, {1: 4626, 2: 478764}), + f"unexpected forward counts {forward}") + require(transpose == (2871, [], {}), f"unexpected transpose counts {transpose}") + print("PASS_BIT_CAUSAL_MULTI_DELIVERY arrivals=5742 union_excluded=5733 " + "exceptional_singles=4626 exceptional_pairs=478764") + + +if __name__ == "__main__": + main() diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/LICENSE b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/NOTICE b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/NOTICE new file mode 100644 index 0000000000..32c2936ea0 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/NOTICE @@ -0,0 +1,26 @@ +Paired E-free BIT specialization and complete accounting, with substantial +OpenAI Codex assistance, for the integer-multiplication research project. +Apache-2.0; LICENSE is retained from the source project. + +DreamingOfClouds (Claude Opus assistance) receives credit for #6834's chain-root +BIT caller, #6937's E-free roots and the underlying two-chain construction. +@CubeJerry (OpenAI assistance) receives credit for #6980's four-input three-query +identity, separated interval replacement and QUERY-only caller. The complete +#6980 proof is retained byte-for-byte in data/6980_PROOF.md. + +The new contribution specializes that existing caller to the actual #6726 BIT +native, supplies the parity-driven pairing of two real 111-port invocations, +and checks the complete E-free finite/compiler/ordinary budget from the selected +ordinary backend. No general QUERY-only mechanism, chain root or new raw kappa +is claimed as new here. + +independent/bit_review.py and independent/interval_gate.py were written by a +separate OpenAI Codex research worker for an implementation-independent scalar +and arithmetic audit. This is model-run checking, not external human review. + +zxv and retained predecessor authors receive credit for #6726's source-native +export, integer-before-mod2 transfer, complete source checking and admission +framework. Ali Romman and Cinna Davis retain the root/native lineage credit. +The copied arithmetic and native checker retain their original headers; see +retained/NOTICE. The selected .0034 backend retains the source and contributor +credits in data/selected_record.json and data/selected_review.md. diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/NOTICE b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/NOTICE new file mode 100644 index 0000000000..16c9afd68e --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/NOTICE @@ -0,0 +1,25 @@ +This research package contains and adapts Apache-2.0 material from +CrocSwap/integer-mult-bounds. The repository's Apache-2.0 license is +provided as LICENSE. + +The six-field mixed-projector architecture and binary-child recursion +are adapted from research/mixed-projector-query-root and its PR6348/PR6398 +lineage, credited there to Ali Romman and Cinna Davis with substantial +OpenAI Codex assistance. The public complex normalization, dyadic bases +and proof by two central characters are not imported as a binary proof. + +The binary projectors, direct characteristic-two operator verification, +complete binary staged callers, exact incidence enumeration and target +economic relaxation in this directory were constructed and checked in +this research session. No novelty or priority assertion is made. + +inputs/interval_engine.py is an unchanged copy of +research/higher-moment-strictification/verify.py, credited to zxv with +substantial OpenAI Codex assistance; its own source notices remain intact. +The broader finite/compiler/ordinary admission in the sibling root +package retains the credit and assumptions of its pinned predecessors. + +The unchanged native source and baseline construction retain all their +original attribution, including their functional kernel, receiver +compensation, temporal retiming, helper exchange and ordinary admission +lineages. No new source-word saving is claimed by this caller package. diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz new file mode 100644 index 0000000000..b718d6b284 Binary files /dev/null and b/research/bit-nine-deadline-relay-floor/retained/pr7741/retained/source-root/research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz differ diff --git a/research/bit-nine-deadline-relay-floor/retained/pr7741/verify.py b/research/bit-nine-deadline-relay-floor/retained/pr7741/verify.py new file mode 100644 index 0000000000..f0361de096 --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/retained/pr7741/verify.py @@ -0,0 +1,303 @@ +"""Check the all-bundle price floor on the retained BIT word. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Nick Petalas supplied the full-donor reduction and two-delivery checker. +""" + +import argparse +from collections import Counter +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys + +PACKAGE = Path(__file__).resolve().parent +SOURCE_ROOT = PACKAGE / "retained/source-root" +EXCEPTIONS = tuple(26861 + 8*i for i in range(9)) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def mask(row): + return sum(1 << coordinate for coordinate in row) + + +def coordinates(value): + result = set() + while value: + low = value & -value + result.add(low.bit_length() - 1) + value ^= low + return result + + +def remainder(row, basis): + row = set(row) + while row: + pivot = max(row) + if pivot not in basis: + break + row.symmetric_difference_update(basis[pivot]) + return row + + +def insert(row, basis): + row = remainder(row, basis) + if row: + basis[max(row)] = frozenset(row) + + +def project(row, ordered_basis): + row = set(row) + for pivot, value in ordered_basis: + if pivot in row: + row.symmetric_difference_update(value) + return frozenset(row) + + +def set_arrivals(word, reverse): + """Interpret each live row as a set of independent input coordinates.""" + charts = list(word["final" if reverse else "start"]) + [None] * 237 + rows = [{i} for i in range(659)] + [set() for _ in range(237)] + sequence = reversed(word["program"]) if reverse else iter(word["program"]) + for clock, instruction in enumerate(sequence): + op, role, *args = instruction + require(0 <= role < len(rows), "independent lane range") + if op == "MOVE": + source, destination = args[::-1] if reverse else args + require(charts[role] == source, "independent MOVE source") + yield clock, source, destination, frozenset(rows[role]) + charts[role] = destination + elif op == "ADD": + donor, chart = args + require(donor != role and 0 <= donor < len(rows), "independent ADD donor") + require(charts[role] == charts[donor] == chart, "independent ADD chart") + if reverse: + rows[donor].symmetric_difference_update(rows[role]) + else: + rows[role].symmetric_difference_update(rows[donor]) + elif op == "SWAP": + (other,) = args + require(0 <= other < len(rows) and other != role, "independent SWAP lane") + rows[role], rows[other] = rows[other], rows[role] + charts[role], charts[other] = charts[other], charts[role] + elif op in ("INIT", "CLEAR"): + (chart,) = args + require(role >= 659, "independent public lifetime") + if (op == "INIT") != reverse: + require(charts[role] is None, "independent INIT state") + charts[role] = chart + else: + require(charts[role] == chart, "independent CLEAR state") + charts[role] = None + rows[role] = set() + else: + raise ValueError("unknown independent operation") + require(charts == list(word["start" if reverse else "final"]) + [None]*237, + "independent exit charts") + + +def load_sources(): + pins = json.loads((PACKAGE / "SOURCE-PINS.json").read_text()) + for pin in pins: + require(hashlib.sha256((PACKAGE / pin["path"]).read_bytes()).hexdigest() + == pin["sha256"], "retained source hash") + file = SOURCE_ROOT / "research/bit-causal-multi-delivery/verify.py" + spec = importlib.util.spec_from_file_location("retained_multi_delivery", file) + source = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = source + spec.loader.exec_module(source) + raw = source.WORD.read_bytes() + require(hashlib.sha256(raw).hexdigest() == source.WORD_SHA256, "native word pin") + word = json.loads(gzip.decompress(raw)) + require((word["public"], word["owned_fields"], len(word["program"])) + == (659, 237, 34137), "native dimensions") + return source, word + + +def prior_checks(source, word): + source.check_controls() + dims, donors = source.nested_donors(word["frames"]) + expected = [(clock, 510+i, 0, 7) for i, clock in enumerate(EXCEPTIONS)] + forward = source.check_orientation(word, dims, donors, False) + transpose = source.check_orientation(word, dims, donors, True) + require(forward == (2871, expected, {1: 4626, 2: 478764}), "predecessor forward") + require(transpose == (2871, [], {}), "predecessor transpose") + return dims, donors + + +def support_inventory(banks, donors, projection): + inventory = [] + for chart, rank in donors[0]: + if rank >= 7 or not banks[chart]: + continue + images = [project(row, projection) for row in banks[chart].values()] + support = frozenset().union(*images) + image_basis = {} + for image in images: + insert(image, image_basis) + inventory.append(dict(chart=chart, rank=rank, image_dimension=len(image_basis), + support_size=len(support), support=hex(mask(support)))) + return inventory + + +def budget_bounds(inventory): + caps = {} + for row in inventory: + caps[row["rank"]] = max(caps.get(row["rank"], 0), row["support_size"]) + bounds = [0]*7 + for budget in range(1, 7): + bounds[budget] = max([bounds[budget-1]] + + [bounds[budget-rank] + cap for rank, cap in caps.items() + if rank <= budget]) + return caps, bounds + + +def check_caps(inventory, caps): + require(all(row["support_size"] <= caps[row["rank"]] for row in inventory), + "false support cap") + + +def separate(target, free_library, cap): + cosets = [target.symmetric_difference(value) for value in free_library] + require(min(map(len, cosets)) > cap, "all-bundle support separation") + return cosets + + +def independent_checks(source, word, dims, donors): + cases = [] + support_rows = None + equality_checks = paired = attainments = 0 + trace = hashlib.sha256() + for reverse in (False, True): + banks = [{} for _ in range(636)] + for coordinate, chart in enumerate(word["final" if reverse else "start"]): + insert({coordinate}, banks[chart]) + free = [frozenset()] + projection = None + source_rows = source.arrivals(word, reverse) + for packed, independent in zip(source_rows, set_arrivals(word, reverse), strict=True): + clock, start, end, row = independent + require((packed.clock, packed.source, packed.destination) == (clock, start, end) + and packed.row == mask(row), "independent paid row") + paired += 1 + trace.update(f"{int(reverse)}:{clock}:{start}:{end}:{mask(row):x}\n".encode()) + rank = abs(dims[start] - dims[end]) + require(rank > 0 and (start, rank) in donors[end], "original route nesting") + require(not remainder(row, banks[start]), "original source attainment") + attainments += 1 + if not reverse and clock in EXCEPTIONS: + require((start, end, rank) == (510+len(cases), 0, 7), "exception identity") + if projection is None: + projection = sorted(banks[0].items(), reverse=True) + require(len(projection) == 524, "base destination rank") + require(all(not project(v, projection) for _, v in projection), + "base destination annihilation") + unit_images = [project({i}, projection) for i in range(659)] + projected_basis = {} + for image in unit_images: + insert(image, projected_basis) + require(len(projected_basis) == 135, "quotient rank") + support_rows = support_inventory(banks, donors, projection) + frozen = {r["chart"]: banks[r["chart"]].copy() for r in support_rows} + caps, bounds = budget_bounds(support_rows) + require(caps == {1: 1, 2: 2, 4: 17, 6: 30}, "donor support caps") + require(bounds == [0, 1, 2, 3, 17, 18, 30], "rank-budget bound") + check_caps(support_rows, caps) + projection_sha = hashlib.sha256(json.dumps( + [hex(mask(v)) for v in unit_images], separators=(",", ":")).encode()).hexdigest() + free_dimension = len(banks[0]) + else: + current_eligible = {chart for chart, r in donors[0] if r < 7 and banks[chart]} + require(current_eligible == set(frozen), "eligible chart set changed") + for chart, bank in frozen.items(): + require(banks[chart] == bank, "lower-rank donor library changed") + equality_checks += 1 + require(len(banks[0]) == free_dimension + len(cases), "destination library growth") + image = project(row, projection) + actual_free = {} + for value in banks[0].values(): + insert(project(value, projection), actual_free) + require(len(actual_free) == len(cases), "projected destination dimension") + require(all(not remainder(v, actual_free) for v in free), "free library inclusion") + require(len(set(free)) == 1 << len(cases), "complete free library") + cosets = separate(image, free, bounds[6]) + distances = Counter(map(len, cosets)) + minimum = min(distances) + cases.append(dict(clock=clock, source=start, destination=end, old_rank=rank, + target=hex(mask(image)), free_dimension=len(actual_free), + cosets=len(cosets), minimum_distance=minimum, + minimum_selector=min(i for i, v in enumerate(cosets) if len(v) == minimum), + distance_histogram={str(k): distances[k] for k in sorted(distances)})) + free += [v.symmetric_difference(image) for v in free] + insert(row, banks[end]) + require(len(cases) == 9 and paired == attainments == 5742, "complete arrival coverage") + require([c["minimum_distance"] for c in cases] == [56, 58, 52, 50, 51, 50, 50, 48, 48], + "coset distances") + return dict(cases=cases, donors=support_rows, donor_caps={str(k): v for k, v in caps.items()}, + rank_budget_bounds=bounds, quotient_rank=135, base_destination_rank=524, + quotient_unit_images_sha256=projection_sha, paid_row_trace_sha256=trace.hexdigest(), + independent_paid_rows=paired, original_source_attainments=attainments, + unchanged_donor_library_checks=equality_checks, + exact_cosets=sum(c["cosets"] for c in cases)) + + +def controls(result): + inventory = result["donors"] + caps = {int(k): v for k, v in result["donor_caps"].items()} + for rank in caps: + false = dict(caps) + false[rank] -= 1 + try: + check_caps(inventory, false) + except ValueError: + continue + raise ValueError("support-cap mutant accepted") + # Equal rank sum is outside the strict saving budget. + require(sum((1, 6)) == 7 and sum((2, 4)) < 7, "strict-budget boundary") + # If the current arrival enters its own free library, the separation fails. + for case in result["cases"]: + target = coordinates(int(case["target"], 16)) + try: + separate(target, [frozenset(), target], result["rank_budget_bounds"][6]) + except ValueError: + continue + raise ValueError("deadline-leak mutant accepted") + # A union is not the binary sum used by the independent interpreter. + a, b = {0, 1}, {1, 2} + require(a.symmetric_difference(b) == {0, 2} and a.union(b) != {0, 2}, + "binary-sum control") + return dict(false_cap_rejections=4, deadline_leak_controls=9, + strict_budget_control=True, binary_sum_control=True) + + +def calculate(): + source, word = load_sources() + dims, donors = prior_checks(source, word) + result = independent_checks(source, word, dims, donors) + result["controls"] = controls(result) + result["inherited_replay"] = dict(arrivals=5742, all_donor_union_exclusions=5733, + exceptional_singletons=4626, exceptional_pairs=478764) + result["scope"] = "All direct bundles from fixed causal libraries attain the original price floor for 0=48>30") + + +if __name__ == "__main__": + main() diff --git a/research/bit-nine-deadline-relay-floor/verify.py b/research/bit-nine-deadline-relay-floor/verify.py new file mode 100644 index 0000000000..83a2c1387d --- /dev/null +++ b/research/bit-nine-deadline-relay-floor/verify.py @@ -0,0 +1,176 @@ +"""Check a rank-budget obstruction to arbitrary relays at nine BIT deadlines. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source support and coset certificate is retained from PR7741. +""" + +import argparse +from collections import Counter +import hashlib +import importlib.util +import json +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load_source(): + for pin in json.loads((PACKAGE / "SOURCE-PINS.json").read_text()): + require(hashlib.sha256((PACKAGE / pin["path"]).read_bytes()).hexdigest() + == pin["sha256"], "retained source hash") + path = PACKAGE / "retained/pr7741/verify.py" + spec = importlib.util.spec_from_file_location("direct_floor", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + result = module.calculate() + require(result == json.loads((path.parent / "RESULT.json").read_text()), + "replayed predecessor receipt") + return module, result + + +def abstract_trees(): + """Bound every labelled rooted tree by removing its root branches.""" + weight = {1: 1, 2: 2, 4: 17} + subtree = {d: [] for d in weight} + for budget in range(7): + for d in weight: + best = 0 + # Attach one branch to a smaller-budget tree with this same root. + for e in weight: + edge = abs(d-e) + if not edge: + continue + for branch_budget in range(edge, budget+1): + root_remainder = subtree[d][budget-branch_budget] - weight[d] + branch = subtree[e][branch_budget-edge] + best = max(best, root_remainder + branch) + subtree[d].append(weight[d] + best) + root = [0]*7 + for budget in range(1, 7): + for d in weight: + for branch_budget in range(d, budget+1): + root[budget] = max(root[budget], root[budget-branch_budget] + + subtree[d][branch_budget-d]) + require(root == [0, 1, 3, 5, 20, 22, 37], "abstract tree budget values") + # The dimension-labelled tree attains 37 in this abstract relaxation. + edges = [(0, 1), (1, 2), (2, 4), (2, 4)] + require(sum(abs(a-b) for a, b in edges) == 6 and 1+2+17+17 == 37, + "abstract tree positive witness") + return dict(root_bounds=root, subtree_bounds={str(k): v for k, v in subtree.items()}, + attaining_dimension_edges=[list(edge) for edge in edges]) + + +def chain_checks(geometry, word, result): + dims, neighbors = geometry.nested_donors(word["frames"]) + dimension_counts = Counter(dims) + require(dimension_counts == {0: 1, 1: 111, 2: 153, 4: 70, 6: 180, 7: 120, 8: 1}, + "complete chart dimensions") + require(dims[0] == 0, "unique zero chart") + supports = {r["chart"]: int(r["support"], 16) for r in result["donors"]} + require(set(supports) == {i for i, d in enumerate(dims) if 0 < d < 7}, + "support coverage of every low chart") + increasing = {i: sorted(j for j, _ in neighbors[i] if dims[i] < dims[j] <= 6) + for i, d in enumerate(dims) if d <= 6} + counts = Counter() + maxima = {} + witnesses = {} + trace = hashlib.sha256() + def visit(path, support): + end = path[-1] + d = dims[end] + counts[d] += 1 + trace.update((",".join(map(str, path)) + ":" + format(support, "x") + "\n").encode()) + if support.bit_count() > maxima.get(d, -1): + maxima[d] = support.bit_count() + witnesses[d] = list(path) + for child in increasing[end]: + visit(path+[child], support | supports[child]) + visit([0], 0) + require(counts == {0: 1, 1: 111, 2: 459, 4: 2224, 6: 37872}, "complete chain counts") + require(maxima == {0: 0, 1: 1, 2: 2, 4: 17, 6: 35}, "chain support maxima") + + # Build the same paths from their final chart in a second pass. + down = {i: {j for j, _ in neighbors[i] if dims[j] < dims[i]} for i in range(636)} + by_end = {0: {(0,)}} + for chart in sorted(supports, key=lambda i: (dims[i], i)): + by_end[chart] = {path+(chart,) for lower in down[chart] + for path in by_end[lower]} + covered = set().union(*by_end.values()) + second_maxima = {} + for chart, paths in by_end.items(): + for path in paths: + support = 0 + for node in path: + support |= supports.get(node, 0) + second_maxima[dims[chart]] = max(second_maxima.get(dims[chart], 0), support.bit_count()) + observed = set() + def collect(path): + observed.add(tuple(path)) + for child in increasing[path[-1]]: + collect(path+[child]) + collect([0]) + require(observed == covered, "reverse path coverage") + require(second_maxima == maxima, "reverse path maxima") + return dict(dimension_counts={str(k): dimension_counts[k] for k in sorted(dimension_counts)}, + increasing_chain_counts={str(k): counts[k] for k in sorted(counts)}, + maximum_supports={str(k): maxima[k] for k in sorted(maxima)}, + attaining_chains={str(k): witnesses[k] for k in sorted(witnesses)}, + chain_trace_sha256=trace.hexdigest(), reverse_path_coverage=len(covered), + reverse_path_maxima={str(k): second_maxima[k] for k in sorted(second_maxima)}) + + +def controls(result): + # Replacing a set union by the largest separate support loses real relays. + require((0b0011 | 0b1100).bit_count() > max(0b0011.bit_count(), 0b1100.bit_count()), + "relay-support union control") + # Three dimension-four leaves need at least eight rank units by level cuts. + require(2+2*3 == 8 > 6, "three-high-branch budget control") + # An extra high edge is not free, even when a path already reaches six. + require(6+1 > 6, "off-path edge control") + require(result["chain_checks"]["maximum_supports"]["6"] > 30, + "direct-only cap must fail for relay chains") + distances = [c["minimum_distance"] for c in result["target_cosets"]] + require(all(v > result["relay_support_bound"] for v in distances), "target separation") + try: + require(all(v > 48 for v in distances), "false strict separation") + except ValueError: + pass + else: + raise ValueError("false strict separation accepted") + return dict(direct_only_cap_rejected=True, false_strict_separation_rejected=True, + support_union_control=True, branch_budget_control=True, off_path_control=True) + + +def calculate(): + predecessor, source_result = load_source() + geometry, word = predecessor.load_sources() + result = dict(abstract_trees=abstract_trees(), chain_checks=chain_checks(geometry, word, source_result), + target_cosets=source_result["cases"], relay_support_bound=37, + independent_coarea_bound=42, scope="Arbitrary fixed-chart paid relay networks at nine rank-seven deadlines; other arrivals not claimed") + require(result["abstract_trees"]["root_bounds"][6] == result["relay_support_bound"], + "complete low-tree bound") + require(result["chain_checks"]["maximum_supports"]["6"] <= result["relay_support_bound"], + "complete high-path bound") + result["controls"] = controls(result) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = calculate() + if args.write_result: + (PACKAGE / "RESULT.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + else: + require(result == json.loads((PACKAGE / "RESULT.json").read_text()), "result mismatch") + print("PASS_BIT_NINE_DEADLINE_RELAY_FLOOR all relays: support<=37<48") + + +if __name__ == "__main__": + main()