diff --git a/research/rank7-six-skip-cap-release/.gitattributes b/research/rank7-six-skip-cap-release/.gitattributes new file mode 100644 index 0000000000..dc29606df8 --- /dev/null +++ b/research/rank7-six-skip-cap-release/.gitattributes @@ -0,0 +1,2 @@ +vendor/** -text +words/** -text diff --git a/research/rank7-six-skip-cap-release/CLAIM.json b/research/rank7-six-skip-cap-release/CLAIM.json new file mode 100644 index 0000000000..f6da716d02 --- /dev/null +++ b/research/rank7-six-skip-cap-release/CLAIM.json @@ -0,0 +1,47 @@ +{ + "admission_sha256": "b1c2b133293daff86b2008a81fe8008d781a22cd09ab56ae3d6f46dba5d6000b", + "baseline_head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "baseline_kappa": "17297361663879159868119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 3042, + "calls": 6660, + "charged_prefix_bits": 2048, + "contribution": "Exact composition of credited PR3042 words and PR3030/3024 allocation, complete finite checks and full release replay.", + "fixed_word_cap_attained": true, + "gain": "178367636256443/100000000000000000000000", + "global_prefix_bits": 1479, + "kappa": "17297379500642785512419999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017297379500642785512419999999999999999999998999999999999999999999999", + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "native_receipt_sha256": "f022b2c493b999cdfa50fc180b6f5770affadc9bb086bc8de2f3a8777bd6e2d8", + "packing_head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "packing_pr": 3030, + "physical": 663549, + "private_zero_buffers": 91, + "profile": { + "1": 16376940, + "2": 4741920, + "3": 1594737, + "4": 719280, + "48": 281903, + "5": 137085, + "8": 53280 + }, + "release_receipt_sha256": "6a3b9e15eb7cf7ca2966b6f47195cf02cfb6fac79590b1b5cfe21a802ee425ee", + "replicas": 740, + "roles": 2717280, + "root": [ + "4324344875160696378107/2500000000000000000000000", + "17297379500642785512429/10000000000000000000000000" + ], + "scientific_review": "pending; not a selected-frontier update", + "scope": "Conditional finite source/native/owner/outer release; inherited all-size, compiler, physical, precision and analytic obligations remain.", + "source_manifest_sha256": "130650ad8833f6df88528c560e4d1cfbae084f4b15a64788a332ddcaff472a17", + "status": "PASS_CONDITIONAL_SIX_SKIP_T740_COMPOSITION" +} diff --git a/research/rank7-six-skip-cap-release/FETCH.txt b/research/rank7-six-skip-cap-release/FETCH.txt new file mode 100644 index 0000000000..d8d8e7d2d7 --- /dev/null +++ b/research/rank7-six-skip-cap-release/FETCH.txt @@ -0,0 +1,12 @@ +git fetch --no-tags https://github.com/CrocSwap/integer-mult-bounds.git \ + 84cc406ad91ec53fff329a11a445d7effe564a77 \ + 78e77d820393c6b8648b47af219e991edfcc54e6 \ + d8e0f83f00191df62174b641e9fff055c357f641 \ + 51309592971e3b5be935599eed2a95404dc7781e \ + 224bd5e56041c40078ff6b5fa7393733a215de5c \ + a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf \ + b74b25f3ccc84c16e1a801d73b2f47e5ea764c78 \ + e62d3eb9005117d82a9babcfa937ecc53237c490 \ + e2ca469b08385d3d5e29a918d66dbefaf889e9f3 \ + 18d03c447886895ef9abf888398178e0428533ca \ + e9307b48d7d1b690939935ecef0f8e524e6d92f4 diff --git a/research/rank7-six-skip-cap-release/MANIFEST.json b/research/rank7-six-skip-cap-release/MANIFEST.json new file mode 100644 index 0000000000..2da999bc03 --- /dev/null +++ b/research/rank7-six-skip-cap-release/MANIFEST.json @@ -0,0 +1,58 @@ +{ + ".gitattributes": "5afc8c7cd1db7ae6d1042a8577cce53e3c512cb4e7608f3d9a507613c6ac4f02", + "CLAIM.json": "f59914dd2687d9c47c1b9ca8ec95ff5b20d4a17eed7dc150b439f0b9bc8c6298", + "FETCH.txt": "695b91df6dcfe7b3c5e2b8b912ea15cd7fba05fed41cb2716250e4613135106b", + "NOTICE": "9df015636574fe4410f87f218c726c39801378d877619d617c74bea500c7ebbc", + "README.md": "a80db73700dfdcc23467964bea90e73aa499197e04efbc027fa57dc531cc0e51", + "SOURCE-PINS.json": "aefe501dcd5312fd57bf537f9d1f6b232cb8d67f88faa1e60ac2c8303b1ed1c1", + "SOURCES.json": "10b03aae02483c02ce4ebfbc2f774dcbb6eff21c221d152e3fc510b8fe329bc5", + "TASK.json": "290ac6146f592e746df5f69fa93f650093440d663323238d78a861ac74b0480c", + "VENDOR.json": "2cbe373cf57d546729979fb29e85d148d378d3c87b94c6675a326556a7c3727f", + "VERIFY.json": "de07a498f241070cc309095af3ee3cd3593b8d0531e2783b4e85e65e12e181dc", + "evidence/ADMISSION-RESULT.json": "b1c2b133293daff86b2008a81fe8008d781a22cd09ab56ae3d6f46dba5d6000b", + "evidence/COMPOSITION-RESULT.json": "b6fe99e8fa26b061ab24ef5711c9a785587a8db5a43f2c1f2fb2e330f31207dc", + "evidence/ENVIRONMENT.json": "7bfa113d97f1773115dd5c60aa6e32b341456d708870e9bfc2a022a7e6dbcce7", + "evidence/FINITE.json": "6b17824cdfdc8ecac9e57b77085127bf3bec4354839f12a4857744ca935f6b87", + "evidence/INVOICE-PAYLOAD.json": "590cb7a9c12db2a49309dd34e9360aae3527e2a21c2b32f9bb1532bc9c4357ba", + "evidence/MATERIALIZED.json": "31e3460e75f9f7c21968bc6f99da0ccf7a6d0a87d0b191d980cf94cfe8ac6b60", + "evidence/NATIVE-RECEIPT.json": "f022b2c493b999cdfa50fc180b6f5770affadc9bb086bc8de2f3a8777bd6e2d8", + "evidence/NATIVE-base-STEPS.json": "c29777578e7f98a08203779a305c53fd6db0ebe8ffed79aadb0eb9e124bf27e9", + "evidence/NATIVE-extra-STEPS.json": "15b5589b50da97b9c42ea1bc8105e811e7980a7ae93e78e11416f55440f9d920", + "evidence/OUTER-CLAIM.json": "2fb2f1dd2c86abe53eb8513b006762c8be542902c99308e4b24642a2b087d3d8", + "evidence/PREFIX-AND-INVOICE.json.gz": "6e1c0974ef360f69293a7f119373e74557600cbbf5604ac56e8ed3b82fe27bce", + "evidence/RECIPE.json": "b2b7701670ab2ac479a64c5fbccea50efea73b307ada931c00e6e094c3d89ae9", + "evidence/RELEASE-RECEIPT.json": "6a3b9e15eb7cf7ca2966b6f47195cf02cfb6fac79590b1b5cfe21a802ee425ee", + "evidence/RETAINED-REUSE-RECEIPT.json": "dd36443f2789ffa6deca7210c76ada781e2b9b7e622a546b366f51a475faff3e", + "evidence/RUN.json": "63364bc8c38331baeebeeff9564324b75ea3fdd0ed858b082f8628c61e1a3aab", + "evidence/logs/complete-admission.log.txt": "16c7e28a72fb06ee6c5e5526e030918739e0f0aaa0a8f2fc5e04eae824a43c48", + "evidence/logs/declared-edit-stage.log.txt": "e0d0595445e237ed99b78764aeb387fea1e7d4e1c5316fc78e49b2ebfc773de5", + "evidence/logs/derive-closed-adapters.log.txt": "cf5381d71952f83a995ef9650b048b6f87807780ba2a7f417c376df0840768af", + "evidence/logs/export-pr2833.log.txt": "7ec13b370a7339288a29ba396b657841241c0f4154dceff6b20f34f4bae05098", + "evidence/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/logs/final-outer.log.txt": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "evidence/logs/final-source.log.txt": "f77be4449fe7fc3ad60adc31688496569bd47ca5a1de0a5434d3f155af392bf0", + "evidence/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/logs/fresh-current-native.log.txt": "57a95a5df95aa0574b48d59d71a6e5e84d017172e51b8627d8713c52a7134206", + "evidence/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "reproduce.py": "958a41ff502dc11cf07835e67a52fa8a946f5785ea9517af6f4cc702c6db605e", + "run_release.py": "1acdcc2f713b04d49954596be435d615bec1838833e1ba112f048072bfae072e", + "test_bindings.py": "f334e67e1ccd2b5eb9430e11aa48fffaa11b07aba3e4bc8518f6cd079bb7a6c1", + "vendor/PR3018-EXCHANGE.json": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "vendor/PR3024-EXCHANGE.json": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827", + "vendor/PR3030-FINITE.json": "00ee90400fa3f35b19a12b89e4d2a2754a02832d4800351657970dc18042b406", + "vendor/PR3042-CAP.json": "ef10b3d6481155eb3cd6f4ce3c82a6919fc5b5bce285d26cef39621989f22d9f", + "vendor/PR3042-CLAIM.json": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3", + "vendor/PR3042-EDITS.json": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "vendor/PR3042-MANIFEST.json": "da2b0fbe030ed5981ea105720042f5be8f56803c141e0be326776eb08e379406", + "vendor/PR3042-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "vendor/PR3042-PROVIDERS.json": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0", + "vendor/cap_proof.py": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f", + "vendor/lift.py": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "verify.py": "418fde9282e72946e48e40944a1b68da36112f520fb9d4d5eef6f9aabeb3ba6e", + "verify_release.py": "43459f1e17a8cd0b7e23ff0aaec5a2cb6aa4fc4e02d6d4b65941a56363ea9de7", + "words/base.json.gz": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "words/extra.json.gz": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35" +} diff --git a/research/rank7-six-skip-cap-release/NOTICE b/research/rank7-six-skip-cap-release/NOTICE new file mode 100644 index 0000000000..6bbe6321ff --- /dev/null +++ b/research/rank7-six-skip-cap-release/NOTICE @@ -0,0 +1,12 @@ +New integration and verification binding: Jeremy Diviney, with substantial +OpenAI Codex assistance. Apache-2.0. + +The scalar constructions, packing witnesses and retained verification engines +are contributions of the named predecessors, not new constructions of this +package. Credit dcharb78 (PR3042), Nick Petalas (PR3018/3024/3030), Jeremy Kothe +(PR3015/2957/2894/2833), Marius-Paul Dumitrean (PR2979/2942), Mason Hale +(PR2917), Jeremy Diviney (PR2908), Yiyang Lu, Tekalign, Ross Richardson, +Dugongue, icekylinx, themilkman216 and their credited source lineage. + +The original retained notice is vendor/PR3042-NOTICE. Source heads, original +paths, Git blob IDs and SHA-256 digests are in SOURCES.json and VENDOR.json. diff --git a/research/rank7-six-skip-cap-release/README.md b/research/rank7-six-skip-cap-release/README.md new file mode 100644 index 0000000000..5275a015f5 --- /dev/null +++ b/research/rank7-six-skip-cap-release/README.md @@ -0,0 +1,157 @@ +# Six restore skips composed with the T740 packing cap + +**Finite checks and the complete composed release pass.** This package composes +dcharb78's PR3042 literal circuit with Nick Petalas's PR3024/3030 T740 allocation. +The finite moment gives the conditional candidate + +``` +kappa = 0.001729737950064278551242 - 10^-46 - 10^-70 +gain over pinned PR3042 = 178367636256443 / 10^23 + ≈ 1.78367636256443e-9 +``` + +This is an integration of two existing constructions. Jeremy Diviney, with +substantial OpenAI Codex assistance, supplies the exact source/word/allocation +binding, completed-profile checks and composed release workflow. There is no new +scalar rewrite or allocation search in this package. No selected-frontier change +or independent human/formal-kernel review is claimed. + +## Concurrent work + +A pre-submission refresh found Petalas's [live claim for the same composition](https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18982402), +posted during this local run, and [PR3050](https://github.com/CrocSwap/integer-mult-bounds/pull/3050)'s +separate code-disjoint substitution/frame audit. This package claims neither +priority nor a unique composition idea. Its additional evidence is a separately +executed complete release and explicit bindings from the checked words and +literal allocation to that release. It reuses credited scientific engines; +separate execution is not code-disjoint verification of those engines. + +## Exact sources and contribution + +| Source | Exact head | Contribution retained | +|---|---|---| +| [PR3042](https://github.com/CrocSwap/integer-mult-bounds/pull/3042), dcharb78 | `84cc406ad91ec53fff329a11a445d7effe564a77` | Both six-skip literal words, declared edits and complete source recipe | +| [PR3030](https://github.com/CrocSwap/integer-mult-bounds/pull/3030), Nick Petalas | `78e77d820393c6b8648b47af219e991edfcc54e6` | PR3024 T740 cap allocation, PR3018 journal, materialization and composition pattern | +| [PR2979](https://github.com/CrocSwap/integer-mult-bounds/pull/2979), Marius-Paul Dumitrean | `be191346391661f4d35fc0d1508d0a6029572576` | Joint rank-seven frames, five paired extractions, native/owner/outer chain | + +Live predecessor files are pinned at main +`d8e0f83f00191df62174b641e9fff055c357f641`, priority revision 6. The selected +conditional result at that checkpoint remains 0.001672660197076918. +`SOURCES.json`, `SOURCE-PINS.json` and `VENDOR.json` identify every retained input. + +The two new source words differ from PR2979 only in `restore`, its derived +inverse cleanup and the paid-profile report. Both complete 123-variable restore +matrices agree exactly with PR2979; the full forward/dual operator auditor checks +all 632 independent inputs. Each of the 408 helper widths is checked in its +original order, not merely through a histogram. The 91 restored endpoints and +their private cleanup buffers remain charged. + +The literal `PR3042-EDITS.json` is the source of the circuit: its two blocks have +26 → 33 and 13 → 15 gates. Some prose in the pinned upstream description gives +different carriers and block lengths; those statements are not used as evidence +here. The retained literal gates pass exact matrix, frame and operator checks. + +## Complete bill and cap + +The per-call local bill is `{1:2433, 2:712, 3:232, 4:108, 5:18, 8:8}`. +The unchanged ordered widths allow the literal T740 allocation to be used with +these words. The source journal and ten-copy lift produce 2,717,280 helper roles +across 6,660 calls. The retained owner checker rechecks every role, chronological +window, physical-family collision, mask and capacity. + +The complete profile is + +``` +{1:16376940, 2:4741920, 3:1594737, 4:719280, + 5:137085, 8:53280, 48:281903} +``` + +For each rank this equals `6660 * local + idle`, where +`idle = {1:173160, 3:49617, 5:17205, 48:281903}`. Its rank mass is +`65088 * 740`. Directed rational arithmetic gives the root bracket + +``` +[0.0017297379500642785512428, 0.0017297379500642785512429]. +``` + +Petalas's retained cap checker recertifies all 2,551 feasible patterns at this +changed local tariff: 12 are identically tight and 2,539 strictly positive. +The literal idle counts equal 740 times the optimal fractional counts, so this +construction attains **100% of its fixed-word packing cap**. This is the +appropriate bound for this fixed-capacity inventory model, not a global ceiling +over other circuits or supplier contracts. + +Physical stock is `896*740 + 408 + 8 + 91 + 2 = 663549`. The stock norm uses +1,324 bits; the conservative reserve is 1,512 within the charged 2,048-bit +payload. The completed strict replay rebuilt the precision, physical and outer +invoice: the actual prefix requirement is 1,479 bits, within 2,048. This uses +about ten times PR3042's fixed physical stock (663,549 versus 66,813); the +larger inventory is fully charged, and the exponent gain is small. + +## Reproduction and evidence + +Bounded registered replay (Python 3.12 standard library): + +```sh +python3.12 -B scripts/research_package.py --package research/rank7-six-skip-cap-release +``` + +`verify.py` recomputes both literal word checks, all ordered widths, full owner +geometry, the complete moment and packing cap. It hashes the reconstructed fill +payload, order and dispatch to bind the finite witness to the actual release. +`verify_release.py` checks stored full-run receipts and their input bindings; +that check does not rerun the native/outer computation. Eight finite controls and +ten receipt/invoice controls target coefficient, width-order, journal, paid-cost, +buffer, payload, source, native and release failures. + +Full replay requires POSIX process groups, the exact source commits in `FETCH.txt` to be +available locally, and Python with NumPy, SciPy, SymPy and mpmath as required by +the retained recipes: + +```sh +OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 \ +python3.12 -B research/rank7-six-skip-cap-release/reproduce.py \ + --repo . --work /tmp/six-skip-cap-fresh --jobs 2 +``` + +The reproducer exports the exact upstream packages, uses PR3030's unchanged +materializer and PR3042's unchanged recipe, and changes exactly its three +complete-admission allocation arguments: fill, order and dispatch. Source +recipes, native checks and admission controls remain intact. `--dry-run` checks +exports/materialization/recipe only. `--retained DIR` explicitly reuses an +authenticated retained cache; both current providers still run fresh. +Regenerated gzip inputs are compared by their complete decompressed payload; +committed source files retain exact byte hashes. + +The recorded run uses authenticated retained evidence from the prior session +and two fresh current five-stage native chains. It must not be described as a +fresh retained bootstrap. The 11 composed source stages passed in 31.3 +minutes with two low-priority single-thread audit workers. Exact logs and raw +receipts are under `evidence/`; `RUN.json` records commands and reuse scope. +The public exporter/materializer/recipe dry run passed separately. A full run +with a freshly bootstrapped retained parent was not performed in this session. + +## Scope + +All inherited all-size/compiler, physical backing and movement, precision/tape, +caller, analytic and universal block-energy hypotheses remain. This is a +conditional finite certificate, not an unconditional integer-multiplication +theorem. Archive merge and scientific admission are distinct. + +## Open next questions + +The next useful task is an independent replay of this exact composition and an +audit of a named remaining admission implication. The fixed-word packing cap +is attained; a further gain in this model requires changing the word, inventory +or coverage contract. See `TASK.json` for the scoped handoff. + +## Credit + +Credit dcharb78/PR3042 for the six-skip word; Jeremy Kothe/PR3015 and PR2957 for +literal edit tooling and predecessor rewrites; Nick Petalas/PR3018, PR3024 and +PR3030 for packing and composition; Marius-Paul Dumitrean/PR2979 and PR2942 for +joint frames and extractions; Mason Hale/PR2917; Jeremy Diviney/PR2908 for paired +extraction; Yiyang Lu, Tekalign, Ross Richardson, Dugongue, icekylinx, +themilkman216, and the retained geometry/native/owner lineage. Original notices +are preserved. New work is Apache-2.0; substantial OpenAI Codex assistance was +used, with no independent human review claimed. diff --git a/research/rank7-six-skip-cap-release/SOURCE-PINS.json b/research/rank7-six-skip-cap-release/SOURCE-PINS.json new file mode 100644 index 0000000000..fb414c01f2 --- /dev/null +++ b/research/rank7-six-skip-cap-release/SOURCE-PINS.json @@ -0,0 +1,14 @@ +{ + "research/rank7-joint-endframes/allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "research/rank7-joint-endframes/allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "research/rank7-joint-endframes/allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "research/rank7-joint-endframes/allocation/PROVIDERS.json": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "research/rank7-joint-endframes/tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "research/rank7-joint-endframes/vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "research/rank7-joint-endframes/vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "research/rank7-joint-endframes/data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "research/rank7-joint-endframes/data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7" +} diff --git a/research/rank7-six-skip-cap-release/SOURCES.json b/research/rank7-six-skip-cap-release/SOURCES.json new file mode 100644 index 0000000000..ca3af96651 --- /dev/null +++ b/research/rank7-six-skip-cap-release/SOURCES.json @@ -0,0 +1,183 @@ +{ + "schema_version": 1, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "usage": "input", + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/PROVIDERS.json", + "usage": "input", + "git_blob": "e1d99e12cfa3ac8375984d85c0b040dc36ea1312", + "sha256": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "usage": "input", + "git_blob": "16013201b19054f7e45398ecf10af74c9c6a9114", + "sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461" + }, + { + "path": "research/rank7-joint-endframes/tools/root.py", + "usage": "input", + "git_blob": "bd6dc2eb4e5013625d17cc08461b67622bcfed69", + "sha256": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3" + }, + { + "path": "research/rank7-joint-endframes/vendor/preload_move.py", + "usage": "input", + "git_blob": "55b435035bbc439a9d55e8abd125993208cef8d9", + "sha256": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044" + }, + { + "path": "research/rank7-joint-endframes/vendor/audit_local.py", + "usage": "input", + "git_blob": "8224873d0497cf0b4c202f31b145fa273553d978", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "usage": "input", + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d" + }, + { + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "usage": "input", + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7" + } + ], + "retained_sources": [ + { + "path": "words/base.json.gz", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-base.json.gz", + "git_blob": "2ee02e318c98281a71445b954feccd55c153827c", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e" + }, + { + "path": "words/extra.json.gz", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-extra.json.gz", + "git_blob": "33ba5f34996a31edd197cb58eca575645575e529", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35" + }, + { + "path": "vendor/PR3042-EDITS.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/EDITS.json", + "git_blob": "c2042a37bdba0febb791d39bcb1f9f55de9fb14e", + "sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79" + }, + { + "path": "vendor/PR3042-CLAIM.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/CLAIM.json", + "git_blob": "47a55a7f68efc1d5babec487d09a1f45f95c3221", + "sha256": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3" + }, + { + "path": "vendor/PR3042-MANIFEST.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/MANIFEST.json", + "git_blob": "7018d721f594be3e22e291f44cfdd59e02a43485", + "sha256": "da2b0fbe030ed5981ea105720042f5be8f56803c141e0be326776eb08e379406" + }, + { + "path": "vendor/PR3042-CAP.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/certificates/RELAX-CAP.json", + "git_blob": "f4c94b6241ed4dc20558a95d10bb6ff47071a07f", + "sha256": "ef10b3d6481155eb3cd6f4ce3c82a6919fc5b5bce285d26cef39621989f22d9f" + }, + { + "path": "vendor/PR3042-PROVIDERS.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/allocation/PROVIDERS.json", + "git_blob": "c0575e39034932eef6c66b1a7848e4d9771e9bf4", + "sha256": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0" + }, + { + "path": "vendor/PR3042-NOTICE", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/NOTICE", + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + { + "path": "vendor/lift.py", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/lift.py", + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c" + }, + { + "path": "vendor/cap_proof.py", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/cap_proof.py", + "git_blob": "28f0995a69fbb003238f5ee8d1acf407bb1b37be", + "sha256": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f" + }, + { + "path": "vendor/PR3024-EXCHANGE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/EXCHANGE.json", + "git_blob": "1b1a904ff05e848bfb2793597b9613cc997c3367", + "sha256": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827" + }, + { + "path": "vendor/PR3018-EXCHANGE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3018/EXCHANGE.json", + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b" + }, + { + "path": "vendor/PR3030-FINITE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/evidence/FINITE.json", + "git_blob": "0ddf2aba4629c09810b336ce92e4dbfc35fca9fa", + "sha256": "00ee90400fa3f35b19a12b89e4d2a2754a02832d4800351657970dc18042b406" + } + ] +} diff --git a/research/rank7-six-skip-cap-release/TASK.json b/research/rank7-six-skip-cap-release/TASK.json new file mode 100644 index 0000000000..d36b512199 --- /dev/null +++ b/research/rank7-six-skip-cap-release/TASK.json @@ -0,0 +1,77 @@ +{ + "actual_scope": "Separately execute and source-bind the exact PR3042 six-skip words composed with PR3030/3024 T740 cap allocation; verify the complete changed finite supplier and outer release.", + "ai_assistance": "Substantial OpenAI Codex assistance for integration, exploratory search, implementation and verification. No independent human or formal-kernel review claimed.", + "author": "Jeremy Diviney", + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "bottleneck_link": "At fixed helper widths, replace T74 idle counts by the literal T740 cap allocation and rerun native/physical/prefix/outer admission on the changed six-skip word.", + "budget_minutes": 60, + "concurrent_work": [ + { + "scope": "Same composition claimed concurrently; no priority claim here.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18982402" + }, + { + "head": "7c9d6b8b01606fa51032c0166f5ed522c8fa5735", + "scope": "Code-disjoint restore substitution/frame audit; separate from this complete source/native/owner/outer replay.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3050" + } + ], + "evidence": "Both literal words and 2,717,280 owner roles checked; exact complete moment and 2,551-pattern packing cap; two fresh current native chains and complete source/physical/prefix/outer release PASS. Authenticated retained parent/native evidence reused explicitly. Stored receipt checks are distinct from rerunning the full release.", + "open_questions": [ + { + "blocked_by": "Maintainer scientific review; no new circuit or packing search is justified by this integration alone.", + "first_step": "Reproduce this exact source/word/allocation composition and inspect the complete bill before any selected-frontier adoption.", + "question": "Can the exact composed finite supplier be independently admitted?", + "why_it_matters": "Its improved conditional endpoint still inherits source/native/physical/compiler/all-size assumptions." + } + ], + "original_card": { + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "independent-moment", + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ], + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ] + }, + "outcome": "completed", + "priority_revision": 6, + "schema_version": 1, + "scope_change_reason": "The assigned continued-improvement search found no saving in a bounded noncommuting cancellation screen. New PR3042 changes the local circuit bill but retains PR2979 widths and T74 packing; the separate T740 cap construction closes its remaining integrality gap. This is a source-bound integration, not a new scalar rewrite or packing search. A pre-submission discussion refresh found Petalas independently claimed the same composition at 20:21 UTC while this run was active. No priority or unique idea is claimed; publish the separately executed complete release and input-to-receipt bindings with explicit overlap.", + "scope_status": "changed", + "stop_rule": "Require both literal words, every owner role, all 91 private buffers, exact moment/cap and complete outer release; no stronger kappa claim from a partial run.", + "task_id": "independent-moment" +} diff --git a/research/rank7-six-skip-cap-release/VENDOR.json b/research/rank7-six-skip-cap-release/VENDOR.json new file mode 100644 index 0000000000..64d6c2dc17 --- /dev/null +++ b/research/rank7-six-skip-cap-release/VENDOR.json @@ -0,0 +1,93 @@ +[ + { + "path": "words/base.json.gz", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-base.json.gz", + "git_blob": "2ee02e318c98281a71445b954feccd55c153827c", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e" + }, + { + "path": "words/extra.json.gz", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/FINAL-WORD-extra.json.gz", + "git_blob": "33ba5f34996a31edd197cb58eca575645575e529", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35" + }, + { + "path": "vendor/PR3042-EDITS.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/edits/EDITS.json", + "git_blob": "c2042a37bdba0febb791d39bcb1f9f55de9fb14e", + "sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79" + }, + { + "path": "vendor/PR3042-CLAIM.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/CLAIM.json", + "git_blob": "47a55a7f68efc1d5babec487d09a1f45f95c3221", + "sha256": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3" + }, + { + "path": "vendor/PR3042-MANIFEST.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/MANIFEST.json", + "git_blob": "7018d721f594be3e22e291f44cfdd59e02a43485", + "sha256": "da2b0fbe030ed5981ea105720042f5be8f56803c141e0be326776eb08e379406" + }, + { + "path": "vendor/PR3042-CAP.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/certificates/RELAX-CAP.json", + "git_blob": "f4c94b6241ed4dc20558a95d10bb6ff47071a07f", + "sha256": "ef10b3d6481155eb3cd6f4ce3c82a6919fc5b5bce285d26cef39621989f22d9f" + }, + { + "path": "vendor/PR3042-PROVIDERS.json", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/allocation/PROVIDERS.json", + "git_blob": "c0575e39034932eef6c66b1a7848e4d9771e9bf4", + "sha256": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0" + }, + { + "path": "vendor/PR3042-NOTICE", + "head": "84cc406ad91ec53fff329a11a445d7effe564a77", + "upstream_path": "research/rank7-restore-carrier-skips/NOTICE", + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661" + }, + { + "path": "vendor/lift.py", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/lift.py", + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c" + }, + { + "path": "vendor/cap_proof.py", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/cap_proof.py", + "git_blob": "28f0995a69fbb003238f5ee8d1acf407bb1b37be", + "sha256": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f" + }, + { + "path": "vendor/PR3024-EXCHANGE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3024/EXCHANGE.json", + "git_blob": "1b1a904ff05e848bfb2793597b9613cc997c3367", + "sha256": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827" + }, + { + "path": "vendor/PR3018-EXCHANGE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/vendor/pr3018/EXCHANGE.json", + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b" + }, + { + "path": "vendor/PR3030-FINITE.json", + "head": "78e77d820393c6b8648b47af219e991edfcc54e6", + "upstream_path": "research/rank7-t740-release/evidence/FINITE.json", + "git_blob": "0ddf2aba4629c09810b336ce92e4dbfc35fca9fa", + "sha256": "00ee90400fa3f35b19a12b89e4d2a2754a02832d4800351657970dc18042b406" + } +] diff --git a/research/rank7-six-skip-cap-release/VERIFY.json b/research/rank7-six-skip-cap-release/VERIFY.json new file mode 100644 index 0000000000..cc1c34c2eb --- /dev/null +++ b/research/rank7-six-skip-cap-release/VERIFY.json @@ -0,0 +1,40 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Exact literal word/frame/width and cleanup checks, all-column forward/dual operator replay, all 2,717,280 owner roles, exact completed moment and all 2,551 packing patterns; bind stored native/admission/release receipts and meaningful rejection controls. Full native/outer replay is separate.", + "timeout_seconds": 600 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/test_bindings.py" + ], + "checks": "Four behavioral groups: exact three-argument recipe adaptation, stale/missing recipe rejection, gzip payload portability, and optimized-interpreter refusal.", + "timeout_seconds": 30 + } + ], + "inputs": [ + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/PROVIDERS.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "research/rank7-joint-endframes/tools/root.py", + "research/rank7-joint-endframes/vendor/preload_move.py", + "research/rank7-joint-endframes/vendor/audit_local.py", + "research/rank7-joint-endframes/data/WORD-base.json.gz", + "research/rank7-joint-endframes/data/WORD-extra.json.gz" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/rank7-six-skip-cap-release/evidence/ADMISSION-RESULT.json b/research/rank7-six-skip-cap-release/evidence/ADMISSION-RESULT.json new file mode 100644 index 0000000000..5a40680814 --- /dev/null +++ b/research/rank7-six-skip-cap-release/evidence/ADMISSION-RESULT.json @@ -0,0 +1,382 @@ +{ + "actual_expected_helpers": 408, + "comparison_claim_sha256": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "comparison_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "comparison_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2969, + "complex_lower": "864868975032139275621/500000000000000000000000", + "dispatch_sha256": "90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0", + "external_input_sha256": { + "/tmp/intmult-six-skip740-allocation/COMPOSED-FILL.json.gz": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c", + "/tmp/intmult-six-skip740-allocation/DISPATCH.json": "90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0", + "/tmp/intmult-six-skip740-allocation/ORDER.json": "927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9", + "/tmp/intmult-six-skip740-full/run/adapters/extension_blocknorm.py": "6e6b8683cc87a84e5410c399b1128eb68694f852a3927cb124067f503ed7d7c7", + "/tmp/intmult-six-skip740-full/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "/tmp/intmult-six-skip740-full/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "/tmp/intmult-six-skip740-full/run/parent-export/pr2894/vendor/pr2857/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "/tmp/intmult-six-skip740-full/run/pr2969/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77" + }, + "fill_sha256": "0608f8cc5f5b2d67de84924540c6166ef109c77af6690c95ef4d9b72f86dad2c", + "gain": "1425681329043418173/250000000000000000000000", + "kappa": "17297379500642785512419999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017297379500642785512419999999999999999999998999999999999999999999999", + "native_receipt_sha256": "f022b2c493b999cdfa50fc180b6f5770affadc9bb086bc8de2f3a8777bd6e2d8", + "order_sha256": "927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9", + "package_manifest_sha256": "b56bd8257820b7aa9abf355842dbfee2d7269a13f302caf7c53e9a56d6cdecad", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "before_sha256": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "path": "geometry_controls.py", + "replacements": [ + [ + " i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1" + ], + [ + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh" + ] + ] + }, + { + "after_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "before_sha256": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + }, + { + "after_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "before_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "path": "outer/check_ledger.py", + "replacements": [ + [ + "assert (m,W)==(73,66304)", + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "2964ea185a64061d72e4a6c648a48cd0ddbfc7ea8174ecb39be2a2eee52a3be8", + "before_sha256": "8dee5aa1663a70edcf1099a30b72166d89c29fa29ba2025fb5707fdbcc237f83", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4baseline,'strict improvement over PR3042') + need(sha(run/'source-edits/MANIFEST.json')==EDIT_SOURCE,'derived literal source binding') + return dict(status='PASS_SIX_SKIP_T740_COMPLETE_RELEASE',kappa=a['kappa'],kappa_decimal=a['kappa_decimal'], + baseline_kappa=str(baseline),gain=str(Q(a['kappa'])-baseline),profile=PROFILE, + source_manifest_sha256=EDIT_SOURCE,admission_sha256=sha(candidate/'RESULT.json'), + release_receipt_sha256=sha(candidate/'release/RELEASE-RECEIPT.json'), + native_receipt_sha256=sha(run/'native/NATIVE-RECEIPT.json'), + scope='Conditional finite source/native/owner/outer release; inherited all-size, compiler, physical, precision and analytic obligations remain.') + +def execute(run,source,allocation,output): + need(__debug__,'inherited validators require assertions');need(not output.exists(),'fresh evidence directory') + need(os.name=='posix','full replay process-group cleanup requires POSIX') + authenticate(source) + allocation_binding(allocation) + recipe,changes=adapt(read(run/'PREFLIGHT.json')['commands'],source,allocation) + output.mkdir(parents=True);save(output/'RECIPE.json',dict(commands=recipe,changes=changes)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1',PYTHONINTMAXSTRDIGITS='0') + for key in ['PYTHONPATH','PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_RECORD','WITNESS_DISCOVER']:env.pop(key,None) + stages=[] + for name,cmd in recipe: + path=output/(name+'.log');start=time.monotonic() + with path.open('w') as log: + proc=subprocess.Popen(cmd,cwd=run,env=env,stdin=subprocess.DEVNULL,stdout=log,stderr=subprocess.STDOUT,start_new_session=True) + try:code=proc.wait(timeout=3600) + finally: + try:os.killpg(proc.pid,signal.SIGTERM) + except ProcessLookupError:pass + try:proc.wait(timeout=5) + except subprocess.TimeoutExpired: + os.killpg(proc.pid,signal.SIGKILL);proc.wait(timeout=5) + try:os.killpg(proc.pid,signal.SIGKILL) + except ProcessLookupError:pass + stages.append(dict(stage=name,exit_code=code,seconds=time.monotonic()-start,log_sha256=sha(path))) + save(output/'STAGES.json',stages);need(code==0,'failed '+name+'; see '+str(path));print('PASS',name,flush=True) + result=validate(run,source,allocation);result['fresh_retained_bootstrap']=any(n=='fresh-retained-bootstrap' for n,_ in recipe) + result['stages']=stages;save(output/'RESULT.json',result);print(result['status'],result['kappa_decimal'],flush=True) + return result + +if __name__=='__main__': + p=argparse.ArgumentParser(description=__doc__) + for key in ['run','source','allocation','output']:p.add_argument('--'+key,type=Path,required=True) + a=p.parse_args();execute(a.run.resolve(),a.source.resolve(),a.allocation.resolve(),a.output.resolve()) diff --git a/research/rank7-six-skip-cap-release/test_bindings.py b/research/rank7-six-skip-cap-release/test_bindings.py new file mode 100644 index 0000000000..649aa2be9e --- /dev/null +++ b/research/rank7-six-skip-cap-release/test_bindings.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Small source/recipe/portability controls without historical replays.""" +import copy +import gzip +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import types +import unittest + +P=Path(__file__).resolve().parent +def load(name): + path=P/(name+'.py');m=types.ModuleType(name);m.__file__=str(path) + exec(compile(path.read_bytes(),str(path),'exec'),m.__dict__);return m +engine=load('run_release') + +class Bindings(unittest.TestCase): + def recipe(self): + source=Path('/pinned/source');recipe=[[name,['python','stage.py']] for name in engine.STAGES] + recipe[-1][1]=['python','admit.py','--source',str(source),'--fill',str(source/'allocation/FILL.json.gz'), + '--order',str(source/'allocation/ORDER.json'),'--dispatch',str(source/'allocation/DISPATCH.json'),'--jobs','2'] + return source,recipe + + def test_exact_three_allocation_arguments(self): + source,original=self.recipe();recipe,changes=engine.adapt(original,source,Path('/new')) + self.assertEqual(original[:-1],recipe[:-1]);self.assertEqual(len(changes),3) + self.assertEqual(sum(a!=b for a,b in zip(original[-1][1],recipe[-1][1])),3) + self.assertEqual(original[-1][1][-2:],recipe[-1][1][-2:]) + self.assertIn(str(source/'allocation/FILL.json.gz'),original[-1][1]) + fresh=copy.deepcopy(original);fresh.insert(2,['fresh-retained-bootstrap',['python','prepare_retained.py']]) + adapted,changes=engine.adapt(fresh,source,Path('/new')) + self.assertEqual(adapted[2],fresh[2]);self.assertEqual(len(changes),3) + + def test_missing_stage_and_stale_preimage_rejected(self): + source,recipe=self.recipe() + with self.assertRaises(ValueError):engine.adapt(recipe[1:],source,Path('/new')) + bad=copy.deepcopy(recipe);bad[-1][1][bad[-1][1].index('--fill')+1]='/other/fill' + with self.assertRaises(ValueError):engine.adapt(bad,source,Path('/new')) + + def test_regenerated_gzip_payload_not_container(self): + saved_payload,saved_alloc=engine.FILL_PAYLOAD,engine.ALLOCATION + payload=b'{"fixture":"same complete payload"}\n' + try: + engine.FILL_PAYLOAD=hashlib.sha256(payload).hexdigest() + with tempfile.TemporaryDirectory() as tmp: + p=Path(tmp) + for name in ['ORDER.json','DISPATCH.json']:(p/name).write_bytes(b'[]\n') + engine.ALLOCATION={name:engine.sha(p/name) for name in ['ORDER.json','DISPATCH.json']} + hashes=[] + for mtime,level in [(0,1),(1234,9)]: + (p/'COMPOSED-FILL.json.gz').write_bytes(gzip.compress(payload,mtime=mtime,compresslevel=level)) + hashes.append(engine.allocation_binding(p)['fill_sha256']) + self.assertNotEqual(*hashes) + (p/'COMPOSED-FILL.json.gz').write_bytes(gzip.compress(payload+b' ',mtime=0)) + with self.assertRaises(ValueError):engine.allocation_binding(p) + finally:engine.FILL_PAYLOAD,engine.ALLOCATION=saved_payload,saved_alloc + + def test_optimized_interpreter_refused(self): + r=subprocess.run([sys.executable,'-O','-B',str(P/'verify.py'),'--finite-only'],capture_output=True,text=True) + self.assertNotEqual(r.returncode,0);self.assertIn('retained checkers require enabled assertions',r.stderr) + +if __name__=='__main__':unittest.main() diff --git a/research/rank7-six-skip-cap-release/vendor/PR3018-EXCHANGE.json b/research/rank7-six-skip-cap-release/vendor/PR3018-EXCHANGE.json new file mode 100644 index 0000000000..1260c8d95f --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3018-EXCHANGE.json @@ -0,0 +1,126 @@ +{ + "schema_version": 1, + "source_pr": 2979, + "source_head": "be191346391661f4d35fc0d1508d0a6029572576", + "edits": [ + [0,[0,0,13,0,41,0],[0,0,32,6,95,0]], + [816,[2,0,32,6,95,0],[2,0,32,6,95,9]], + [16336,[40,16,3,4,0,9],[40,16,32,6,94,9]], + [20453,[50,53,26,6,5,0],[50,53,3,4,4,9]], + [20458,[50,58,26,6,4,0],[50,58,3,4,3,9]], + [20469,[50,69,26,6,3,0],[50,69,3,4,2,18]], + [20474,[50,74,26,6,2,0],[50,74,3,4,1,18]], + [26450,[64,338,3,4,4,9],[64,338,3,4,4,13]], + [26452,[64,340,3,4,3,9],[64,340,3,4,3,13]], + [29401,[72,25,28,4,0,0],[72,25,3,4,0,9]], + [30439,[74,247,3,4,4,18],[74,247,3,4,4,22]], + [30447,[74,255,3,4,3,18],[74,255,3,4,3,22]], + [30449,[74,257,3,4,2,18],[74,257,3,4,2,22]], + [30456,[74,264,3,4,1,18],[74,264,3,4,1,22]], + [30457,[74,265,3,4,0,18],[74,265,32,6,93,9]], + [30847,[75,247,40,4,4,18],[75,247,32,6,92,9]], + [31281,[76,273,2,5,31,0],[76,273,3,4,0,16]], + [33559,[82,103,12,1,9,0],[82,103,13,0,41,0]], + [33595,[82,139,12,1,8,0],[82,139,3,4,0,24]], + [33967,[83,103,49,1,9,0],[83,103,13,0,41,8]], + [35384,[86,296,13,0,41,9],[86,296,28,4,0,0]], + [44066,[108,2,5,5,98,0],[108,2,2,5,31,0]], + [49778,[122,2,11,4,7,24],[122,2,49,1,9,0]], + [49915,[122,139,11,4,0,24],[122,139,12,1,9,0]], + [50323,[123,139,48,4,0,24],[123,139,12,1,8,0]], + [52434,[128,210,26,6,5,4],[128,210,26,6,5,0]], + [52435,[128,211,26,6,4,4],[128,211,26,6,4,0]], + [52436,[128,212,26,6,3,4],[128,212,26,6,3,0]], + [52437,[128,213,26,6,2,4],[128,213,26,6,2,0]], + [58754,[144,2,18,1,98,0],[144,2,5,5,98,0]], + [66098,[162,2,28,6,13,0],[162,2,11,4,0,24]], + [66100,[162,4,17,6,88,9],[162,4,11,4,7,24]], + [66506,[163,2,65,6,13,0],[163,2,48,4,0,24]], + [67768,[166,40,28,6,13,8],[166,40,28,6,13,0]], + [68176,[167,40,65,6,13,8],[167,40,65,6,13,0]], + [78338,[192,2,19,6,3,0],[192,2,17,6,88,9]], + [78340,[192,4,19,6,2,0],[192,4,18,1,98,0]], + [84180,[206,132,19,6,3,8],[206,132,19,6,3,0]], + [84182,[206,134,19,6,2,8],[206,134,19,6,2,0]], + [86594,[212,98,19,6,3,17],[212,98,19,6,3,9]], + [86596,[212,100,19,6,2,17],[212,100,19,6,2,9]], + [107848,[264,136,26,6,5,13],[264,136,26,6,5,9]], + [107849,[264,137,26,6,4,13],[264,137,26,6,4,9]], + [107852,[264,140,26,6,3,13],[264,140,26,6,3,9]], + [107853,[264,141,26,6,2,13],[264,141,26,6,2,9]], + [109346,[268,2,36,4,1,6],[268,2,19,6,3,18]], + [109348,[268,4,36,4,0,6],[268,4,19,6,2,18]], + [133061,[326,53,23,13,111,9],[326,53,26,6,5,18]], + [133469,[327,53,60,13,111,9],[327,53,26,6,4,18]], + [134760,[330,120,36,4,1,14],[330,120,36,4,1,6]], + [134761,[330,121,36,4,0,14],[330,121,36,4,0,6]], + [144485,[354,53,19,15,58,0],[354,53,26,6,3,18]], + [144490,[354,58,19,15,57,0],[354,58,26,6,2,18]], + [161079,[394,327,28,6,13,17],[394,327,28,6,13,9]], + [161487,[395,327,65,6,13,17],[395,327,65,6,13,9]], + [161961,[396,393,21,14,39,0],[396,393,28,6,13,15]], + [161962,[396,394,21,14,38,0],[396,394,65,6,13,15]], + [161963,[396,395,21,14,37,0],[396,395,36,4,1,15]], + [161964,[396,396,21,14,36,0],[396,396,36,4,0,15]], + [165872,[406,224,32,6,95,9],[406,224,32,6,95,18]], + [165873,[406,225,32,6,94,9],[406,225,32,6,94,18]], + [165874,[406,226,32,6,93,9],[406,226,32,6,93,18]], + [165875,[406,227,32,6,92,9],[406,227,32,6,92,18]], + [167396,[410,116,21,14,39,8],[410,116,21,14,39,0]], + [167398,[410,118,21,14,38,8],[410,118,21,14,38,0]], + [167399,[410,119,21,14,37,8],[410,119,21,14,37,0]], + [167400,[410,120,21,14,36,8],[410,120,21,14,36,0]], + [172176,[422,0,32,6,95,15],[422,0,23,13,111,9]], + [172177,[422,1,32,6,94,15],[422,1,60,13,111,9]], + [172179,[422,3,32,6,93,15],[422,3,26,13,111,9]], + [172181,[422,5,32,6,92,15],[422,5,63,13,111,9]], + [175513,[430,73,19,15,58,4],[430,73,19,15,58,0]], + [175516,[430,76,19,15,57,4],[430,76,19,15,57,0]], + [189539,[464,227,21,14,39,17],[464,227,21,14,39,9]], + [189540,[464,228,21,14,38,17],[464,228,21,14,38,9]], + [189541,[464,229,21,14,37,17],[464,229,21,14,37,9]], + [189542,[464,230,21,14,36,17],[464,230,21,14,36,9]], + [204318,[500,318,19,15,58,13],[500,318,19,15,58,9]], + [204319,[500,319,19,15,57,13],[500,319,19,15,57,9]], + [218754,[536,66,26,13,111,9],[536,66,26,13,111,18]], + [219162,[537,66,63,13,111,9],[537,66,63,13,111,18]], + [219721,[538,217,19,15,58,22],[538,217,19,15,58,18]], + [219722,[538,218,19,15,57,22],[538,218,19,15,57,18]], + [226106,[554,74,26,13,111,18],[554,74,19,15,58,27]], + [226514,[555,74,63,13,111,18],[555,74,19,15,57,27]], + [229431,[562,135,21,14,39,23],[562,135,21,14,39,15]], + [229432,[562,136,21,14,38,23],[562,136,21,14,38,15]], + [229433,[562,137,21,14,37,23],[562,137,21,14,37,15]], + [229436,[562,140,21,14,36,23],[562,140,21,14,36,15]], + [232084,[568,340,26,13,111,22],[568,340,26,13,111,27]], + [232492,[569,340,63,13,111,22],[569,340,63,13,111,27]], + [233782,[572,406,26,13,111,31],[572,406,21,14,38,24]], + [233783,[572,407,23,13,111,13],[572,407,21,14,39,24]], + [234190,[573,406,63,13,111,31],[573,406,21,14,36,24]], + [234191,[573,407,60,13,111,13],[573,407,21,14,37,24]], + [237796,[582,340,23,13,111,21],[582,340,23,13,111,18]], + [238204,[583,340,60,13,111,21],[583,340,60,13,111,18]], + [240720,[590,0,26,13,111,39],[590,0,26,13,111,36]], + [241128,[591,0,63,13,111,39],[591,0,63,13,111,36]], + [243508,[596,340,23,13,111,30],[596,340,23,13,111,27]], + [243916,[597,340,60,13,111,30],[597,340,60,13,111,27]], + [245140,[600,340,23,13,111,39],[600,340,23,13,111,36]], + [245548,[601,340,60,13,111,39],[601,340,60,13,111,36]] + ], + "routes": [ + [[20453,[3,4,4]],[133061,[26,6,5]]], + [[20458,[3,4,3]],[133469,[26,6,4]]], + [[20469,[3,4,2]],[144485,[26,6,3]],[226106,[19,15,58]]], + [[20474,[3,4,1]],[144490,[26,6,2]],[226514,[19,15,57]]], + [[29401,[3,4,0]],[35384,[28,4,0]]], + [[33559,[13,0,41]],[49915,[12,1,9]],[66098,[11,4,0]],[161961,[28,6,13]],[233783,[21,14,39]]], + [[33595,[3,4,0]],[50323,[12,1,8]],[66506,[48,4,0]],[161962,[65,6,13]],[233782,[21,14,38]]], + [[33967,[13,0,41]],[49778,[49,1,9]],[66100,[11,4,7]],[78338,[17,6,88]],[109346,[19,6,3]],[161963,[36,4,1]],[234191,[21,14,37]]], + [[31281,[3,4,0]],[44066,[2,5,31]],[58754,[5,5,98]],[78340,[18,1,98]],[109348,[19,6,2]],[161964,[36,4,0]],[234190,[21,14,36]]], + [[172176,[23,13,111]],[0,[32,6,95]]], + [[172177,[60,13,111]],[16336,[32,6,94]]], + [[172179,[26,13,111]],[30457,[32,6,93]]], + [[172181,[63,13,111]],[30847,[32,6,92]]] + ], + "changed_pattern_bins": [[23,13,111],[60,13,111],[26,13,111],[63,13,111],[3,4,4],[3,4,3],[3,4,2],[3,4,1],[3,4,0],[40,4,4],[13,0,41]] +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3024-EXCHANGE.json b/research/rank7-six-skip-cap-release/vendor/PR3024-EXCHANGE.json new file mode 100644 index 0000000000..1b1a904ff0 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3024-EXCHANGE.json @@ -0,0 +1,559 @@ +{ + "schema_version": 1, + "source_pr": 3018, + "source_head": "ca7113157d7c959fdfa9d7cd17ef92d3877070d0", + "copies": 10, + "indexing": "copy * 271728 + base_index; lifted time = 10 * base_time + copy; owner = base_owner + 74 * copy", + "edits": [ + [447,[10,39,40,4,4,0],[10,39,410,4,4,0]], + [26858,[650,338,40,4,4,9],[650,338,410,4,4,18]], + [34068,[830,204,49,1,3,0],[830,204,262,4,4,0]], + [34097,[830,233,49,1,2,0],[830,233,188,4,4,8]], + [34098,[830,234,49,1,1,0],[830,234,114,4,4,16]], + [34100,[830,236,49,1,0,0],[830,236,40,4,4,24]], + [109754,[2690,2,73,4,1,6],[2690,2,654,1,3,0]], + [109756,[2690,4,73,4,0,6],[2690,4,654,1,2,0]], + [199512,[4890,0,72,13,111,0],[4890,0,35,13,111,9]], + [201552,[4940,0,35,13,111,9],[4940,0,35,13,111,18]], + [201960,[4950,0,72,13,111,9],[4950,0,72,13,111,18]], + [208286,[5100,206,26,14,0,0],[5100,206,627,13,111,0]], + [208694,[5110,206,63,14,0,0],[5110,206,627,13,111,9]], + [210540,[5160,12,26,14,0,9],[5160,12,627,13,111,18]], + [210948,[5170,12,63,14,0,9],[5170,12,627,13,111,27]], + [211362,[5180,18,31,14,0,0],[5180,18,31,14,0,14]], + [211770,[5190,18,68,14,0,0],[5190,18,68,14,0,14]], + [216240,[5300,0,26,14,0,18],[5300,0,627,13,111,36]], + [216648,[5310,0,63,14,0,18],[5310,0,26,14,0,22]], + [219504,[5380,0,35,13,111,18],[5380,0,35,13,111,27]], + [219912,[5390,0,72,13,111,18],[5390,0,72,13,111,27]], + [227666,[5580,2,31,14,0,9],[5580,2,650,14,35,6]], + [228074,[5590,2,68,14,0,9],[5590,2,650,14,34,6]], + [244322,[5980,338,31,14,0,17],[5980,338,31,14,0,23]], + [244730,[5990,338,68,14,0,17],[5990,338,68,14,0,23]], + [244965,[6000,165,35,13,111,27],[6000,165,26,14,0,0]], + [245373,[6010,165,72,13,111,27],[6010,165,63,14,0,0]], + [254593,[6240,1,35,13,111,31],[6240,1,35,13,111,36]], + [255001,[6250,1,72,13,111,31],[6250,1,72,13,111,36]], + [263953,[6460,385,35,13,111,40],[6460,385,734,14,0,6]], + [264361,[6470,385,72,13,111,40],[6470,385,697,14,0,6]], + [265527,[6500,327,31,14,0,26],[6500,327,31,14,0,0]], + [265935,[6510,327,68,14,0,26],[6510,327,68,14,0,0]], + [272175,[11,39,114,4,4,0],[11,39,410,4,4,9]], + [298586,[651,338,114,4,4,9],[651,338,484,4,4,9]], + [305796,[831,204,123,1,3,0],[831,204,336,4,4,0]], + [305825,[831,233,123,1,2,0],[831,233,262,4,4,8]], + [305826,[831,234,123,1,1,0],[831,234,188,4,4,16]], + [305828,[831,236,123,1,0,0],[831,236,114,4,4,24]], + [381482,[2691,2,147,4,1,6],[2691,2,654,1,1,0]], + [381484,[2691,4,147,4,0,6],[2691,4,654,1,0,0]], + [470832,[4881,0,109,13,111,0],[4881,0,72,13,111,0]], + [471240,[4891,0,146,13,111,0],[4891,0,109,13,111,0]], + [473280,[4941,0,109,13,111,9],[4941,0,72,13,111,9]], + [473688,[4951,0,146,13,111,9],[4951,0,109,13,111,9]], + [480014,[5101,206,100,14,0,0],[5101,206,26,14,0,4]], + [480422,[5111,206,137,14,0,0],[5111,206,63,14,0,4]], + [482268,[5161,12,100,14,0,9],[5161,12,26,14,0,13]], + [482676,[5171,12,137,14,0,9],[5171,12,63,14,0,13]], + [483090,[5181,18,105,14,0,0],[5181,18,105,14,0,14]], + [483498,[5191,18,142,14,0,0],[5191,18,142,14,0,14]], + [487968,[5301,0,100,14,0,18],[5301,0,63,14,0,22]], + [488376,[5311,0,137,14,0,18],[5311,0,100,14,0,22]], + [491640,[5391,0,146,13,111,18],[5391,0,109,13,111,27]], + [499394,[5581,2,105,14,0,9],[5581,2,650,14,33,6]], + [499802,[5591,2,142,14,0,9],[5591,2,650,14,32,6]], + [516050,[5981,338,105,14,0,17],[5981,338,105,14,0,23]], + [516458,[5991,338,142,14,0,17],[5991,338,142,14,0,23]], + [516693,[6001,165,109,13,111,27],[6001,165,100,14,0,0]], + [517101,[6011,165,146,13,111,27],[6011,165,137,14,0,0]], + [526321,[6241,1,109,13,111,31],[6241,1,109,13,111,36]], + [526729,[6251,1,146,13,111,31],[6251,1,146,13,111,36]], + [535681,[6461,385,109,13,111,40],[6461,385,660,14,0,6]], + [536089,[6471,385,146,13,111,40],[6471,385,623,14,0,6]], + [537255,[6501,327,105,14,0,26],[6501,327,105,14,0,0]], + [537663,[6511,327,142,14,0,26],[6511,327,142,14,0,0]], + [543903,[12,39,188,4,4,0],[12,39,484,4,4,0]], + [570314,[652,338,188,4,4,9],[652,338,484,4,4,18]], + [577553,[832,233,197,1,2,0],[832,233,336,4,4,8]], + [577554,[832,234,197,1,1,0],[832,234,262,4,4,16]], + [577556,[832,236,197,1,0,0],[832,236,188,4,4,24]], + [653210,[2692,2,221,4,1,6],[2692,2,728,1,15,0]], + [653212,[2692,4,221,4,0,6],[2692,4,728,1,14,0]], + [742560,[4882,0,183,13,111,0],[4882,0,146,13,111,0]], + [742968,[4892,0,220,13,111,0],[4892,0,183,13,111,9]], + [745008,[4942,0,183,13,111,9],[4942,0,146,13,111,9]], + [745416,[4952,0,220,13,111,9],[4952,0,183,13,111,18]], + [751742,[5102,206,174,14,0,0],[5102,206,100,14,0,4]], + [752150,[5112,206,211,14,0,0],[5112,206,137,14,0,4]], + [753996,[5162,12,174,14,0,9],[5162,12,100,14,0,13]], + [754404,[5172,12,211,14,0,9],[5172,12,137,14,0,13]], + [754818,[5182,18,179,14,0,0],[5182,18,179,14,0,14]], + [755226,[5192,18,216,14,0,0],[5192,18,216,14,0,14]], + [759696,[5302,0,174,14,0,18],[5302,0,137,14,0,22]], + [760104,[5312,0,211,14,0,18],[5312,0,174,14,0,22]], + [762960,[5382,0,183,13,111,18],[5382,0,146,13,111,18]], + [763368,[5392,0,220,13,111,18],[5392,0,183,13,111,27]], + [771122,[5582,2,179,14,0,9],[5582,2,650,14,19,6]], + [771530,[5592,2,216,14,0,9],[5592,2,650,14,18,6]], + [787778,[5982,338,179,14,0,17],[5982,338,179,14,0,23]], + [788186,[5992,338,216,14,0,17],[5992,338,216,14,0,23]], + [788421,[6002,165,183,13,111,27],[6002,165,174,14,0,0]], + [788829,[6012,165,220,13,111,27],[6012,165,211,14,0,0]], + [798049,[6242,1,183,13,111,31],[6242,1,146,13,111,27]], + [798457,[6252,1,220,13,111,31],[6252,1,183,13,111,36]], + [807409,[6462,385,183,13,111,40],[6462,385,586,14,0,6]], + [807817,[6472,385,220,13,111,40],[6472,385,549,14,0,6]], + [808983,[6502,327,179,14,0,26],[6502,327,179,14,0,0]], + [809391,[6512,327,216,14,0,26],[6512,327,216,14,0,0]], + [815631,[13,39,262,4,4,0],[13,39,558,4,4,0]], + [842042,[653,338,262,4,4,9],[653,338,558,4,4,18]], + [849282,[833,234,271,1,1,0],[833,234,336,4,4,16]], + [849284,[833,236,271,1,0,0],[833,236,262,4,4,24]], + [924938,[2693,2,295,4,1,6],[2693,2,728,1,13,0]], + [924940,[2693,4,295,4,0,6],[2693,4,728,1,12,0]], + [1014288,[4883,0,257,13,111,0],[4883,0,183,13,111,0]], + [1014696,[4893,0,294,13,111,0],[4893,0,220,13,111,0]], + [1016736,[4943,0,257,13,111,9],[4943,0,220,13,111,9]], + [1017144,[4953,0,294,13,111,9],[4953,0,220,13,111,18]], + [1023470,[5103,206,248,14,0,0],[5103,206,174,14,0,4]], + [1023878,[5113,206,285,14,0,0],[5113,206,211,14,0,4]], + [1025724,[5163,12,248,14,0,9],[5163,12,174,14,0,13]], + [1026132,[5173,12,285,14,0,9],[5173,12,211,14,0,13]], + [1026546,[5183,18,253,14,0,0],[5183,18,253,14,0,14]], + [1026954,[5193,18,290,14,0,0],[5193,18,290,14,0,14]], + [1031424,[5303,0,248,14,0,18],[5303,0,211,14,0,22]], + [1031832,[5313,0,285,14,0,18],[5313,0,248,14,0,22]], + [1034688,[5383,0,257,13,111,18],[5383,0,220,13,111,27]], + [1035096,[5393,0,294,13,111,18],[5393,0,257,13,111,27]], + [1042850,[5583,2,253,14,0,9],[5583,2,650,14,17,6]], + [1043258,[5593,2,290,14,0,9],[5593,2,650,14,16,6]], + [1059506,[5983,338,253,14,0,17],[5983,338,253,14,0,23]], + [1059914,[5993,338,290,14,0,17],[5993,338,290,14,0,23]], + [1060149,[6003,165,257,13,111,27],[6003,165,248,14,0,0]], + [1060557,[6013,165,294,13,111,27],[6013,165,285,14,0,0]], + [1069777,[6243,1,257,13,111,31],[6243,1,220,13,111,36]], + [1070185,[6253,1,294,13,111,31],[6253,1,257,13,111,36]], + [1079137,[6463,385,257,13,111,40],[6463,385,512,14,0,6]], + [1079545,[6473,385,294,13,111,40],[6473,385,475,14,0,6]], + [1080711,[6503,327,253,14,0,26],[6503,327,253,14,0,0]], + [1081119,[6513,327,290,14,0,26],[6513,327,290,14,0,0]], + [1087359,[14,39,336,4,4,0],[14,39,558,4,4,9]], + [1113770,[654,338,336,4,4,9],[654,338,632,4,4,9]], + [1121012,[834,236,345,1,0,0],[834,236,336,4,4,24]], + [1196666,[2694,2,369,4,1,6],[2694,2,728,1,11,0]], + [1196668,[2694,4,369,4,0,6],[2694,4,728,1,10,0]], + [1286016,[4884,0,331,13,111,0],[4884,0,257,13,111,0]], + [1286424,[4894,0,368,13,111,0],[4894,0,294,13,111,0]], + [1288464,[4944,0,331,13,111,9],[4944,0,257,13,111,9]], + [1288872,[4954,0,368,13,111,9],[4954,0,294,13,111,9]], + [1295198,[5104,206,322,14,0,0],[5104,206,248,14,0,4]], + [1295606,[5114,206,359,14,0,0],[5114,206,285,14,0,4]], + [1297452,[5164,12,322,14,0,9],[5164,12,248,14,0,13]], + [1297860,[5174,12,359,14,0,9],[5174,12,285,14,0,13]], + [1298274,[5184,18,327,14,0,0],[5184,18,327,14,0,14]], + [1298682,[5194,18,364,14,0,0],[5194,18,364,14,0,14]], + [1303152,[5304,0,322,14,0,18],[5304,0,285,14,0,22]], + [1303560,[5314,0,359,14,0,18],[5314,0,322,14,0,22]], + [1306416,[5384,0,331,13,111,18],[5384,0,257,13,111,18]], + [1306824,[5394,0,368,13,111,18],[5394,0,294,13,111,18]], + [1314578,[5584,2,327,14,0,9],[5584,2,724,14,39,6]], + [1314986,[5594,2,364,14,0,9],[5594,2,724,14,38,6]], + [1331234,[5984,338,327,14,0,17],[5984,338,327,14,0,23]], + [1331642,[5994,338,364,14,0,17],[5994,338,364,14,0,23]], + [1331877,[6004,165,331,13,111,27],[6004,165,322,14,0,0]], + [1332285,[6014,165,368,13,111,27],[6014,165,359,14,0,0]], + [1341505,[6244,1,331,13,111,31],[6244,1,294,13,111,27]], + [1341913,[6254,1,368,13,111,31],[6254,1,294,13,111,36]], + [1350865,[6464,385,331,13,111,40],[6464,385,438,14,0,6]], + [1351273,[6474,385,368,13,111,40],[6474,385,401,14,0,6]], + [1352439,[6504,327,327,14,0,26],[6504,327,327,14,0,0]], + [1352847,[6514,327,364,14,0,26],[6514,327,364,14,0,0]], + [1359087,[15,39,410,4,4,0],[15,39,632,4,4,0]], + [1385498,[655,338,410,4,4,9],[655,338,632,4,4,18]], + [1468394,[2695,2,443,4,1,6],[2695,2,728,1,9,0]], + [1468396,[2695,4,443,4,0,6],[2695,4,728,1,8,0]], + [1557744,[4885,0,405,13,111,0],[4885,0,331,13,111,0]], + [1558152,[4895,0,442,13,111,0],[4895,0,331,13,111,9]], + [1560192,[4945,0,405,13,111,9],[4945,0,331,13,111,18]], + [1560600,[4955,0,442,13,111,9],[4955,0,368,13,111,18]], + [1566926,[5105,206,396,14,0,0],[5105,206,322,14,0,4]], + [1567334,[5115,206,433,14,0,0],[5115,206,359,14,0,4]], + [1569180,[5165,12,396,14,0,9],[5165,12,322,14,0,13]], + [1569588,[5175,12,433,14,0,9],[5175,12,359,14,0,13]], + [1570002,[5185,18,401,14,0,0],[5185,18,401,14,0,14]], + [1570410,[5195,18,438,14,0,0],[5195,18,438,14,0,14]], + [1574880,[5305,0,396,14,0,18],[5305,0,359,14,0,22]], + [1575288,[5315,0,433,14,0,18],[5315,0,396,14,0,22]], + [1578144,[5385,0,405,13,111,18],[5385,0,331,13,111,27]], + [1578552,[5395,0,442,13,111,18],[5395,0,368,13,111,27]], + [1586306,[5585,2,401,14,0,9],[5585,2,724,14,37,6]], + [1586714,[5595,2,438,14,0,9],[5595,2,724,14,36,6]], + [1602962,[5985,338,401,14,0,17],[5985,338,401,14,0,23]], + [1603370,[5995,338,438,14,0,17],[5995,338,438,14,0,23]], + [1603605,[6005,165,405,13,111,27],[6005,165,396,14,0,0]], + [1604013,[6015,165,442,13,111,27],[6015,165,433,14,0,0]], + [1613233,[6245,1,405,13,111,31],[6245,1,331,13,111,36]], + [1613641,[6255,1,442,13,111,31],[6255,1,368,13,111,36]], + [1622593,[6465,385,405,13,111,40],[6465,385,364,14,0,6]], + [1623001,[6475,385,442,13,111,40],[6475,385,327,14,0,6]], + [1624167,[6505,327,401,14,0,26],[6505,327,401,14,0,0]], + [1624575,[6515,327,438,14,0,26],[6515,327,438,14,0,0]], + [1630815,[16,39,484,4,4,0],[16,39,706,4,4,0]], + [1657226,[656,338,484,4,4,9],[656,338,706,4,4,18]], + [1740122,[2696,2,517,4,1,6],[2696,2,728,1,7,0]], + [1740124,[2696,4,517,4,0,6],[2696,4,728,1,6,0]], + [1829472,[4886,0,479,13,111,0],[4886,0,368,13,111,0]], + [1829880,[4896,0,516,13,111,0],[4896,0,405,13,111,0]], + [1831920,[4946,0,479,13,111,9],[4946,0,368,13,111,9]], + [1832328,[4956,0,516,13,111,9],[4956,0,405,13,111,9]], + [1838654,[5106,206,470,14,0,0],[5106,206,396,14,0,4]], + [1839062,[5116,206,507,14,0,0],[5116,206,433,14,0,4]], + [1840908,[5166,12,470,14,0,9],[5166,12,396,14,0,13]], + [1841316,[5176,12,507,14,0,9],[5176,12,433,14,0,13]], + [1841730,[5186,18,475,14,0,0],[5186,18,475,14,0,14]], + [1842138,[5196,18,512,14,0,0],[5196,18,512,14,0,14]], + [1846608,[5306,0,470,14,0,18],[5306,0,433,14,0,22]], + [1847016,[5316,0,507,14,0,18],[5316,0,470,14,0,22]], + [1849872,[5386,0,479,13,111,18],[5386,0,405,13,111,18]], + [1850280,[5396,0,516,13,111,18],[5396,0,405,13,111,27]], + [1858034,[5586,2,475,14,0,9],[5586,2,724,14,35,6]], + [1858442,[5596,2,512,14,0,9],[5596,2,724,14,34,6]], + [1874690,[5986,338,475,14,0,17],[5986,338,475,14,0,23]], + [1875098,[5996,338,512,14,0,17],[5996,338,512,14,0,23]], + [1875333,[6006,165,479,13,111,27],[6006,165,470,14,0,0]], + [1875741,[6016,165,516,13,111,27],[6016,165,507,14,0,0]], + [1884961,[6246,1,479,13,111,31],[6246,1,405,13,111,36]], + [1885369,[6256,1,516,13,111,31],[6256,1,442,13,111,36]], + [1894321,[6466,385,479,13,111,40],[6466,385,290,14,0,6]], + [1894729,[6476,385,516,13,111,40],[6476,385,253,14,0,6]], + [1895895,[6506,327,475,14,0,26],[6506,327,475,14,0,0]], + [1896303,[6516,327,512,14,0,26],[6516,327,512,14,0,0]], + [1902543,[17,39,558,4,4,0],[17,39,706,4,4,9]], + [1928954,[657,338,558,4,4,9],[657,338,737,4,0,5]], + [1935788,[827,236,530,1,0,0],[827,236,40,4,4,0]], + [1935961,[837,1,566,4,6,0],[837,1,566,4,6,14]], + [1935963,[837,3,566,4,5,0],[837,3,566,4,5,14]], + [1935965,[837,5,566,4,4,0],[837,5,566,4,4,14]], + [1935967,[837,7,566,4,3,0],[837,7,566,4,3,14]], + [1935968,[837,8,566,4,2,0],[837,8,566,4,2,14]], + [1935969,[837,9,566,4,1,0],[837,9,566,4,1,14]], + [1937831,[877,239,566,4,6,9],[877,239,566,4,6,23]], + [1937832,[877,240,566,4,5,9],[877,240,566,4,5,23]], + [1937833,[877,241,566,4,4,9],[877,241,566,4,4,23]], + [1937834,[877,242,566,4,3,9],[877,242,566,4,3,23]], + [1937835,[877,243,566,4,2,9],[877,243,566,4,2,23]], + [1937836,[877,244,566,4,1,9],[877,244,566,4,1,23]], + [1943583,[1017,279,566,4,6,18],[1017,279,566,4,6,0]], + [1943584,[1017,280,566,4,5,18],[1017,280,566,4,5,0]], + [1943606,[1017,302,566,4,4,18],[1017,302,566,4,4,0]], + [1943607,[1017,303,566,4,3,18],[1017,303,566,4,3,0]], + [1943630,[1017,326,566,4,2,18],[1017,326,566,4,2,0]], + [1943631,[1017,327,566,4,1,18],[1017,327,566,4,1,0]], + [1952284,[1237,4,566,4,6,24],[1237,4,123,1,3,0]], + [1952286,[1237,6,566,4,5,24],[1237,6,197,1,2,0]], + [1952360,[1237,80,566,4,4,24],[1237,80,271,1,1,0]], + [1952367,[1237,87,566,4,3,24],[1237,87,345,1,0,0]], + [1952376,[1237,96,566,4,2,24],[1237,96,49,1,3,0]], + [1952383,[1237,103,566,4,1,24],[1237,103,123,1,2,0]], + [2011850,[2697,2,591,4,1,6],[2697,2,728,1,5,0]], + [2011852,[2697,4,591,4,0,6],[2697,4,728,1,4,0]], + [2101200,[4887,0,553,13,111,0],[4887,0,442,13,111,0]], + [2101608,[4897,0,590,13,111,0],[4897,0,479,13,111,9]], + [2103648,[4947,0,553,13,111,9],[4947,0,442,13,111,9]], + [2104056,[4957,0,590,13,111,9],[4957,0,479,13,111,18]], + [2110382,[5107,206,544,14,0,0],[5107,206,470,14,0,4]], + [2110790,[5117,206,581,14,0,0],[5117,206,507,14,0,4]], + [2112636,[5167,12,544,14,0,9],[5167,12,470,14,0,13]], + [2113044,[5177,12,581,14,0,9],[5177,12,507,14,0,13]], + [2113458,[5187,18,549,14,0,0],[5187,18,549,14,0,14]], + [2113866,[5197,18,586,14,0,0],[5197,18,586,14,0,14]], + [2118336,[5307,0,544,14,0,18],[5307,0,507,14,0,22]], + [2118744,[5317,0,581,14,0,18],[5317,0,544,14,0,22]], + [2121600,[5387,0,553,13,111,18],[5387,0,442,13,111,18]], + [2122008,[5397,0,590,13,111,18],[5397,0,479,13,111,27]], + [2129762,[5587,2,549,14,0,9],[5587,2,724,14,33,6]], + [2130170,[5597,2,586,14,0,9],[5597,2,724,14,32,6]], + [2146418,[5987,338,549,14,0,17],[5987,338,549,14,0,23]], + [2146826,[5997,338,586,14,0,17],[5997,338,586,14,0,23]], + [2147061,[6007,165,553,13,111,27],[6007,165,544,14,0,0]], + [2147469,[6017,165,590,13,111,27],[6017,165,581,14,0,0]], + [2156689,[6247,1,553,13,111,31],[6247,1,442,13,111,27]], + [2157097,[6257,1,590,13,111,31],[6257,1,479,13,111,36]], + [2166049,[6467,385,553,13,111,40],[6467,385,216,14,0,6]], + [2166457,[6477,385,590,13,111,40],[6477,385,179,14,0,6]], + [2167623,[6507,327,549,14,0,26],[6507,327,549,14,0,0]], + [2168031,[6517,327,586,14,0,26],[6517,327,586,14,0,0]], + [2174271,[18,39,632,4,4,0],[18,39,700,4,0,5]], + [2200682,[658,338,632,4,4,9],[658,338,737,4,1,5]], + [2202055,[698,79,646,6,37,0],[698,79,646,6,37,14]], + [2202057,[698,81,646,6,36,0],[698,81,646,6,36,14]], + [2202058,[698,82,646,6,35,0],[698,82,646,6,35,14]], + [2202060,[698,84,646,6,34,0],[698,84,646,6,34,14]], + [2207514,[828,234,604,1,1,0],[828,234,114,4,4,0]], + [2207516,[828,236,604,1,0,0],[828,236,40,4,4,8]], + [2207688,[838,0,640,4,7,0],[838,0,640,4,7,14]], + [2207689,[838,1,640,4,6,0],[838,1,640,4,6,14]], + [2207691,[838,3,640,4,5,0],[838,3,640,4,5,14]], + [2207693,[838,5,640,4,4,0],[838,5,640,4,4,14]], + [2207695,[838,7,640,4,3,0],[838,7,640,4,3,14]], + [2207696,[838,8,640,4,2,0],[838,8,640,4,2,14]], + [2207697,[838,9,640,4,1,0],[838,9,640,4,1,14]], + [2209557,[878,237,640,4,7,9],[878,237,640,4,7,23]], + [2209559,[878,239,640,4,6,9],[878,239,640,4,6,23]], + [2209560,[878,240,640,4,5,9],[878,240,640,4,5,23]], + [2209561,[878,241,640,4,4,9],[878,241,640,4,4,23]], + [2209562,[878,242,640,4,3,9],[878,242,640,4,3,23]], + [2209563,[878,243,640,4,2,9],[878,243,640,4,2,23]], + [2209564,[878,244,640,4,1,9],[878,244,640,4,1,23]], + [2215291,[1018,259,640,4,7,18],[1018,259,640,4,7,0]], + [2215311,[1018,279,640,4,6,18],[1018,279,640,4,6,0]], + [2215312,[1018,280,640,4,5,18],[1018,280,640,4,5,0]], + [2215334,[1018,302,640,4,4,18],[1018,302,640,4,4,0]], + [2215335,[1018,303,640,4,3,18],[1018,303,640,4,3,0]], + [2215358,[1018,326,640,4,2,18],[1018,326,640,4,2,0]], + [2215359,[1018,327,640,4,1,18],[1018,327,640,4,1,0]], + [2224010,[1238,2,640,4,7,24],[1238,2,197,1,1,0]], + [2224012,[1238,4,640,4,6,24],[1238,4,271,1,0,0]], + [2224014,[1238,6,640,4,5,24],[1238,6,678,1,2,0]], + [2224088,[1238,80,640,4,4,24],[1238,80,49,1,2,0]], + [2224095,[1238,87,640,4,3,24],[1238,87,123,1,1,0]], + [2224104,[1238,96,640,4,2,24],[1238,96,197,1,0,0]], + [2224111,[1238,103,640,4,1,24],[1238,103,604,1,1,0]], + [2240561,[1638,233,646,6,37,9],[1638,233,566,4,6,6]], + [2240562,[1638,234,646,6,36,9],[1638,234,566,4,5,6]], + [2240564,[1638,236,646,6,35,9],[1638,236,566,4,4,6]], + [2240566,[1638,238,646,6,34,9],[1638,238,566,4,3,6]], + [2266719,[2278,279,646,6,37,17],[2278,279,646,6,37,0]], + [2266720,[2278,280,646,6,36,17],[2278,280,646,6,36,0]], + [2266742,[2278,302,646,6,35,17],[2278,302,646,6,35,0]], + [2266743,[2278,303,646,6,34,17],[2278,303,646,6,34,0]], + [2274188,[2458,404,654,1,3,0],[2458,404,646,6,37,6]], + [2274189,[2458,405,654,1,2,0],[2458,405,646,6,36,6]], + [2274190,[2458,406,654,1,1,0],[2458,406,646,6,35,6]], + [2274191,[2458,407,654,1,0,0],[2458,407,646,6,34,6]], + [2283578,[2698,2,665,4,1,6],[2698,2,728,1,3,0]], + [2283580,[2698,4,665,4,0,6],[2698,4,728,1,2,0]], + [2336197,[3978,397,650,14,35,0],[3978,397,73,4,1,6]], + [2336198,[3978,398,650,14,34,0],[3978,398,73,4,0,6]], + [2336199,[3978,399,650,14,33,0],[3978,399,147,4,1,6]], + [2336200,[3978,400,650,14,32,0],[3978,400,147,4,0,6]], + [2336201,[3978,401,650,14,19,0],[3978,401,221,4,1,6]], + [2336204,[3978,404,650,14,18,0],[3978,404,221,4,0,6]], + [2336205,[3978,405,650,14,17,0],[3978,405,295,4,1,6]], + [2336206,[3978,406,650,14,16,0],[3978,406,295,4,0,6]], + [2341633,[4118,121,650,14,35,8],[4118,121,650,14,35,14]], + [2341635,[4118,123,650,14,34,8],[4118,123,650,14,34,14]], + [2341636,[4118,124,650,14,33,8],[4118,124,650,14,33,14]], + [2341637,[4118,125,650,14,32,8],[4118,125,650,14,32,14]], + [2341814,[4118,302,650,14,19,8],[4118,302,650,14,19,0]], + [2341815,[4118,303,650,14,18,8],[4118,303,650,14,18,0]], + [2341838,[4118,326,650,14,17,8],[4118,326,650,14,17,0]], + [2341839,[4118,327,650,14,16,8],[4118,327,650,14,16,0]], + [2363775,[4658,231,650,14,35,17],[4658,231,650,14,35,0]], + [2363802,[4658,258,650,14,34,17],[4658,258,650,14,34,0]], + [2363803,[4658,259,650,14,33,17],[4658,259,650,14,33,0]], + [2363823,[4658,279,650,14,32,17],[4658,279,650,14,32,0]], + [2372928,[4888,0,627,13,111,0],[4888,0,479,13,111,0]], + [2373336,[4898,0,664,13,111,0],[4898,0,516,13,111,0]], + [2375376,[4948,0,627,13,111,9],[4948,0,516,13,111,9]], + [2375784,[4958,0,664,13,111,9],[4958,0,516,13,111,18]], + [2382110,[5108,206,618,14,0,0],[5108,206,544,14,0,4]], + [2382518,[5118,206,655,14,0,0],[5118,206,581,14,0,4]], + [2384364,[5168,12,618,14,0,9],[5168,12,544,14,0,13]], + [2384772,[5178,12,655,14,0,9],[5178,12,581,14,0,13]], + [2385186,[5188,18,623,14,0,0],[5188,18,623,14,0,14]], + [2385594,[5198,18,660,14,0,0],[5198,18,660,14,0,14]], + [2390064,[5308,0,618,14,0,18],[5308,0,581,14,0,22]], + [2390472,[5318,0,655,14,0,18],[5318,0,618,14,0,22]], + [2393328,[5388,0,627,13,111,18],[5388,0,516,13,111,27]], + [2393736,[5398,0,664,13,111,18],[5398,0,553,13,111,27]], + [2401490,[5588,2,623,14,0,9],[5588,2,724,14,19,6]], + [2401898,[5598,2,660,14,0,9],[5598,2,724,14,18,6]], + [2418146,[5988,338,623,14,0,17],[5988,338,623,14,0,23]], + [2418554,[5998,338,660,14,0,17],[5998,338,660,14,0,23]], + [2418789,[6008,165,627,13,111,27],[6008,165,618,14,0,0]], + [2419197,[6018,165,664,13,111,27],[6018,165,655,14,0,0]], + [2428417,[6248,1,627,13,111,31],[6248,1,516,13,111,36]], + [2428825,[6258,1,664,13,111,31],[6258,1,553,13,111,36]], + [2437777,[6468,385,627,13,111,40],[6468,385,142,14,0,6]], + [2438185,[6478,385,664,13,111,40],[6478,385,105,14,0,6]], + [2439351,[6508,327,623,14,0,26],[6508,327,623,14,0,0]], + [2439759,[6518,327,660,14,0,26],[6518,327,660,14,0,0]], + [2445999,[19,39,706,4,4,0],[19,39,700,4,1,5]], + [2472410,[659,338,706,4,4,9],[659,338,739,4,98,4]], + [2473723,[699,19,720,6,88,0],[699,19,720,6,88,14]], + [2473724,[699,20,720,6,87,0],[699,20,720,6,87,14]], + [2473770,[699,66,720,6,47,0],[699,66,720,6,47,14]], + [2473771,[699,67,720,6,46,0],[699,67,720,6,46,14]], + [2473772,[699,68,720,6,45,0],[699,68,720,6,45,14]], + [2473774,[699,70,720,6,44,0],[699,70,720,6,44,14]], + [2473775,[699,71,720,6,43,0],[699,71,720,6,43,14]], + [2473776,[699,72,720,6,42,0],[699,72,720,6,42,14]], + [2473777,[699,73,720,6,41,0],[699,73,720,6,41,14]], + [2473780,[699,76,720,6,40,0],[699,76,720,6,40,14]], + [2473781,[699,77,720,6,39,0],[699,77,720,6,39,14]], + [2473782,[699,78,720,6,38,0],[699,78,720,6,38,14]], + [2473783,[699,79,720,6,37,0],[699,79,720,6,37,14]], + [2473785,[699,81,720,6,36,0],[699,81,720,6,36,14]], + [2473786,[699,82,720,6,35,0],[699,82,720,6,35,14]], + [2473788,[699,84,720,6,34,0],[699,84,720,6,34,14]], + [2474967,[729,39,700,4,1,0],[729,39,700,4,1,14]], + [2474968,[729,40,700,4,0,0],[729,40,700,4,0,14]], + [2475375,[739,39,737,4,1,0],[739,39,737,4,1,14]], + [2475376,[739,40,737,4,0,0],[739,40,737,4,0,14]], + [2479241,[829,233,678,1,2,0],[829,233,188,4,4,0]], + [2479242,[829,234,678,1,1,0],[829,234,114,4,4,8]], + [2479244,[829,236,678,1,0,0],[829,236,40,4,4,16]], + [2479416,[839,0,714,4,7,0],[839,0,714,4,7,14]], + [2479417,[839,1,714,4,6,0],[839,1,714,4,6,14]], + [2479419,[839,3,714,4,5,0],[839,3,714,4,5,14]], + [2479421,[839,5,714,4,4,0],[839,5,714,4,4,14]], + [2479423,[839,7,714,4,3,0],[839,7,714,4,3,14]], + [2479424,[839,8,714,4,2,0],[839,8,714,4,2,14]], + [2479425,[839,9,714,4,1,0],[839,9,714,4,1,14]], + [2481285,[879,237,714,4,7,9],[879,237,714,4,7,23]], + [2481287,[879,239,714,4,6,9],[879,239,714,4,6,23]], + [2481288,[879,240,714,4,5,9],[879,240,714,4,5,23]], + [2481289,[879,241,714,4,4,9],[879,241,714,4,4,23]], + [2481290,[879,242,714,4,3,9],[879,242,714,4,3,23]], + [2481291,[879,243,714,4,2,9],[879,243,714,4,2,23]], + [2481292,[879,244,714,4,1,9],[879,244,714,4,1,23]], + [2483124,[929,36,700,4,1,9],[929,36,700,4,1,23]], + [2483125,[929,37,700,4,0,9],[929,37,700,4,0,23]], + [2483532,[939,36,737,4,1,9],[939,36,737,4,1,23]], + [2483533,[939,37,737,4,0,9],[939,37,737,4,0,23]], + [2487019,[1019,259,714,4,7,18],[1019,259,714,4,7,0]], + [2487039,[1019,279,714,4,6,18],[1019,279,714,4,6,0]], + [2487040,[1019,280,714,4,5,18],[1019,280,714,4,5,0]], + [2487062,[1019,302,714,4,4,18],[1019,302,714,4,4,0]], + [2487063,[1019,303,714,4,3,18],[1019,303,714,4,3,0]], + [2487086,[1019,326,714,4,2,18],[1019,326,714,4,2,0]], + [2487087,[1019,327,714,4,1,18],[1019,327,714,4,1,0]], + [2495738,[1239,2,714,4,7,24],[1239,2,678,1,1,0]], + [2495740,[1239,4,714,4,6,24],[1239,4,49,1,1,0]], + [2495742,[1239,6,714,4,5,24],[1239,6,123,1,0,0]], + [2495816,[1239,80,714,4,4,24],[1239,80,530,1,0,0]], + [2495823,[1239,87,714,4,3,24],[1239,87,604,1,0,0]], + [2495832,[1239,96,714,4,2,24],[1239,96,678,1,0,0]], + [2495839,[1239,103,714,4,1,24],[1239,103,49,1,0,0]], + [2512060,[1639,4,720,6,88,9],[1639,4,566,4,2,6]], + [2512062,[1639,6,720,6,87,9],[1639,6,566,4,1,6]], + [2512136,[1639,80,720,6,47,9],[1639,80,640,4,7,6]], + [2512143,[1639,87,720,6,46,9],[1639,87,640,4,6,6]], + [2512152,[1639,96,720,6,45,9],[1639,96,640,4,5,6]], + [2512159,[1639,103,720,6,44,9],[1639,103,640,4,4,6]], + [2512195,[1639,139,720,6,43,9],[1639,139,640,4,3,6]], + [2512227,[1639,171,720,6,42,9],[1639,171,640,4,2,6]], + [2512240,[1639,184,720,6,41,9],[1639,184,640,4,1,6]], + [2512244,[1639,188,720,6,40,9],[1639,188,714,4,7,6]], + [2512256,[1639,200,720,6,39,9],[1639,200,714,4,6,6]], + [2512260,[1639,204,720,6,38,9],[1639,204,714,4,5,6]], + [2512289,[1639,233,720,6,37,9],[1639,233,714,4,4,6]], + [2512290,[1639,234,720,6,36,9],[1639,234,714,4,3,6]], + [2512292,[1639,236,720,6,35,9],[1639,236,714,4,2,6]], + [2512294,[1639,238,720,6,34,9],[1639,238,714,4,1,6]], + [2525438,[1959,326,720,6,88,17],[1959,326,720,6,88,0]], + [2525439,[1959,327,720,6,87,17],[1959,327,720,6,87,0]], + [2538392,[2279,224,720,6,47,17],[2279,224,720,6,47,0]], + [2538393,[2279,225,720,6,46,17],[2279,225,720,6,46,0]], + [2538394,[2279,226,720,6,45,17],[2279,226,720,6,45,0]], + [2538395,[2279,227,720,6,44,17],[2279,227,720,6,44,0]], + [2538396,[2279,228,720,6,43,17],[2279,228,720,6,43,0]], + [2538397,[2279,229,720,6,42,17],[2279,229,720,6,42,0]], + [2538398,[2279,230,720,6,41,17],[2279,230,720,6,41,0]], + [2538399,[2279,231,720,6,40,17],[2279,231,720,6,40,0]], + [2538426,[2279,258,720,6,39,17],[2279,258,720,6,39,0]], + [2538427,[2279,259,720,6,38,17],[2279,259,720,6,38,0]], + [2538447,[2279,279,720,6,37,17],[2279,279,720,6,37,0]], + [2538448,[2279,280,720,6,36,17],[2279,280,720,6,36,0]], + [2538470,[2279,302,720,6,35,17],[2279,302,720,6,35,0]], + [2538471,[2279,303,720,6,34,17],[2279,303,720,6,34,0]], + [2544858,[2439,162,739,4,98,0],[2439,162,739,4,98,13]], + [2545902,[2459,390,728,1,15,0],[2459,390,720,6,88,6]], + [2545903,[2459,391,728,1,14,0],[2459,391,720,6,87,6]], + [2545904,[2459,392,728,1,13,0],[2459,392,720,6,47,6]], + [2545905,[2459,393,728,1,12,0],[2459,393,720,6,46,6]], + [2545906,[2459,394,728,1,11,0],[2459,394,720,6,45,6]], + [2545907,[2459,395,728,1,10,0],[2459,395,720,6,44,6]], + [2545908,[2459,396,728,1,9,0],[2459,396,720,6,43,6]], + [2545909,[2459,397,728,1,8,0],[2459,397,720,6,42,6]], + [2545910,[2459,398,728,1,7,0],[2459,398,720,6,41,6]], + [2545911,[2459,399,728,1,6,0],[2459,399,720,6,40,6]], + [2545912,[2459,400,728,1,5,0],[2459,400,720,6,39,6]], + [2545913,[2459,401,728,1,4,0],[2459,401,720,6,38,6]], + [2545916,[2459,404,728,1,3,0],[2459,404,720,6,37,6]], + [2545917,[2459,405,728,1,2,0],[2459,405,720,6,36,6]], + [2545918,[2459,406,728,1,1,0],[2459,406,720,6,35,6]], + [2545919,[2459,407,728,1,0,0],[2459,407,720,6,34,6]], + [2555306,[2699,2,739,4,1,6],[2699,2,728,1,1,0]], + [2555308,[2699,4,739,4,0,6],[2699,4,728,1,0,0]], + [2607921,[3979,393,724,14,39,0],[3979,393,369,4,1,6]], + [2607922,[3979,394,724,14,38,0],[3979,394,369,4,0,6]], + [2607923,[3979,395,724,14,37,0],[3979,395,443,4,1,6]], + [2607924,[3979,396,724,14,36,0],[3979,396,443,4,0,6]], + [2607925,[3979,397,724,14,35,0],[3979,397,517,4,1,6]], + [2607926,[3979,398,724,14,34,0],[3979,398,517,4,0,6]], + [2607927,[3979,399,724,14,33,0],[3979,399,591,4,1,6]], + [2607928,[3979,400,724,14,32,0],[3979,400,591,4,0,6]], + [2607929,[3979,401,724,14,19,0],[3979,401,665,4,1,6]], + [2607932,[3979,404,724,14,18,0],[3979,404,665,4,0,6]], + [2607933,[3979,405,724,14,17,0],[3979,405,739,4,1,6]], + [2607934,[3979,406,724,14,16,0],[3979,406,739,4,0,6]], + [2613356,[4119,116,724,14,39,8],[4119,116,724,14,39,14]], + [2613358,[4119,118,724,14,38,8],[4119,118,724,14,38,14]], + [2613359,[4119,119,724,14,37,8],[4119,119,724,14,37,14]], + [2613360,[4119,120,724,14,36,8],[4119,120,724,14,36,14]], + [2613361,[4119,121,724,14,35,8],[4119,121,724,14,35,14]], + [2613363,[4119,123,724,14,34,8],[4119,123,724,14,34,14]], + [2613364,[4119,124,724,14,33,8],[4119,124,724,14,33,14]], + [2613365,[4119,125,724,14,32,8],[4119,125,724,14,32,14]], + [2613542,[4119,302,724,14,19,8],[4119,302,724,14,19,0]], + [2613543,[4119,303,724,14,18,8],[4119,303,724,14,18,0]], + [2613566,[4119,326,724,14,17,8],[4119,326,724,14,17,0]], + [2613567,[4119,327,724,14,16,8],[4119,327,724,14,16,0]], + [2632109,[4579,101,739,4,98,9],[4579,101,739,4,98,0]], + [2633802,[4619,162,739,4,98,13],[4619,162,739,4,98,22]], + [2635499,[4659,227,724,14,39,17],[4659,227,724,14,39,0]], + [2635500,[4659,228,724,14,38,17],[4659,228,724,14,38,0]], + [2635501,[4659,229,724,14,37,17],[4659,229,724,14,37,0]], + [2635502,[4659,230,724,14,36,17],[4659,230,724,14,36,0]], + [2635503,[4659,231,724,14,35,17],[4659,231,724,14,35,0]], + [2635530,[4659,258,724,14,34,17],[4659,258,724,14,34,0]], + [2635531,[4659,259,724,14,33,17],[4659,259,724,14,33,0]], + [2635551,[4659,279,724,14,32,17],[4659,279,724,14,32,0]], + [2642778,[4839,162,739,4,98,22],[4839,162,729,14,0,4]], + [2644656,[4889,0,701,13,111,0],[4889,0,553,13,111,0]], + [2645064,[4899,0,738,13,111,0],[4899,0,590,13,111,0]], + [2646332,[4929,44,700,4,1,18],[4929,44,729,14,0,13]], + [2646333,[4929,45,700,4,0,18],[4929,45,692,14,0,4]], + [2646740,[4939,44,737,4,1,18],[4939,44,729,14,0,22]], + [2646741,[4939,45,737,4,0,18],[4939,45,692,14,0,13]], + [2647104,[4949,0,701,13,111,9],[4949,0,553,13,111,9]], + [2647506,[4949,402,700,4,1,27],[4949,402,700,4,1,0]], + [2647507,[4949,403,700,4,0,27],[4949,403,700,4,0,0]], + [2647512,[4959,0,738,13,111,9],[4959,0,590,13,111,9]], + [2647914,[4959,402,737,4,1,27],[4959,402,737,4,1,0]], + [2647915,[4959,403,737,4,0,27],[4959,403,737,4,0,0]], + [2653838,[5109,206,692,14,0,0],[5109,206,618,14,0,4]], + [2654246,[5119,206,729,14,0,0],[5119,206,655,14,0,4]], + [2656092,[5169,12,692,14,0,9],[5169,12,618,14,0,13]], + [2656500,[5179,12,729,14,0,9],[5179,12,655,14,0,13]], + [2656914,[5189,18,697,14,0,0],[5189,18,697,14,0,14]], + [2657322,[5199,18,734,14,0,0],[5199,18,734,14,0,14]], + [2661792,[5309,0,692,14,0,18],[5309,0,655,14,0,22]], + [2662200,[5319,0,729,14,0,18],[5319,0,692,14,0,22]], + [2665056,[5389,0,701,13,111,18],[5389,0,553,13,111,18]], + [2665464,[5399,0,738,13,111,18],[5399,0,590,13,111,18]], + [2673218,[5589,2,697,14,0,9],[5589,2,724,14,17,6]], + [2673626,[5599,2,734,14,0,9],[5599,2,724,14,16,6]], + [2689874,[5989,338,697,14,0,17],[5989,338,697,14,0,23]], + [2690282,[5999,338,734,14,0,17],[5999,338,734,14,0,23]], + [2690517,[6009,165,701,13,111,27],[6009,165,692,14,0,0]], + [2690925,[6019,165,738,13,111,27],[6019,165,729,14,0,0]], + [2700145,[6249,1,701,13,111,31],[6249,1,590,13,111,27]], + [2700553,[6259,1,738,13,111,31],[6259,1,590,13,111,36]], + [2709505,[6469,385,701,13,111,40],[6469,385,68,14,0,6]], + [2709913,[6479,385,738,13,111,40],[6479,385,31,14,0,6]], + [2711079,[6509,327,697,14,0,26],[6509,327,697,14,0,0]], + [2711487,[6519,327,734,14,0,26],[6519,327,734,14,0,0]] + ] +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3030-FINITE.json b/research/rank7-six-skip-cap-release/vendor/PR3030-FINITE.json new file mode 100644 index 0000000000..0ddf2aba46 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3030-FINITE.json @@ -0,0 +1,94 @@ +{ + "calls": 6660, + "idle": { + "1": 173160, + "3": 49617, + "48": 281903, + "5": 17205 + }, + "live": 663040, + "moment": { + "exchange_sign": { + "delta": { + "1": 20, + "14": -10, + "3": 17, + "48": 3, + "5": -15 + }, + "factored_f_derivative_upper": "-9740691/100000", + "saving_interval": "0 < b <= 1/100" + }, + "gain_over_previous_root": [ + "15520213124915363/10000000000000000000000000", + "3104042624983073/2000000000000000000000000" + ], + "previous_released_kappa": "17291512039830184429979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "r1_cap": { + "cap_lower": "345830551200866186907/200000000000000000000000", + "cap_upper": "17291527560043309345351/10000000000000000000000000", + "idle_per_replica": { + "1": "234", + "3": "1341/20", + "48": "7619/20", + "5": "93/4" + }, + "invariant": { + "cap_requires_T_multiple_of": 20, + "first_multiple_of_74": 740, + "identity": "20*N_[9,9,9,9,9]@48 = 1341*T", + "scope": "Pattern integrality; chronological sufficiency is not asserted." + }, + "minimum_slack_lower": "330765675305227204675371142393288108400151493175513616739741339618653761718041326298111057624781171125553985546713931380045589238715164684519680158082564740064663626585139779201278666945976271879210312552348945421842669479860034347625742282914882395550466970485099678801067095436401756055414599223858358045300620622572136335593899309576755132023072924000625232706202289892486468856482758190936016483225256005340027972594846416378903928488242877276718725872416334489569899876284894464567074525397636741615414416512178272514355557374077726632979830127341350785520875007989552785927437863408466173223802409362040928161903300682009368388022327606117750186058531177130486222532353473629990336123001666673453285550918689932752488873889800407408618663032684827164043100388063145568074124864004671327888352440148634170348081682763216459720440600473567758633447479756936881069232841299315182009213270746341095947229872623984953305659320971822234633628503084874050627189372339056880769747466281694324513868890186542568399493669814325528063369943581616724732903252851537556934617596147852096403830386971101932076078846509096157094005135661650016075760947032213965707873129939184689263987243478656040906464411334211690007822733347623898160446742448648210266592497727349409694316897300189398121201087445724945334874140855821854415515276641951455907807350241364838774433095096175333305053290637933525897282705413481161097167181637390050045065310941579633986151479433320996941088323147696390012023269/81041342522688389710889387537294203079509119498590816677390723091620647310394495647029073126180702147730052952998589633954567841435821298786820185301991996265365431464176659884385965729599723770208940372607986728020752670720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "patterns": 2551, + "strict_patterns": 2539, + "tight_patterns": 12 + }, + "root": [ + "345830551200866186907/200000000000000000000000", + "17291527560043309345351/10000000000000000000000000" + ] + }, + "physical": 663549, + "profile": { + "1": 16443540, + "2": 4708620, + "3": 1594737, + "4": 719280, + "48": 281903, + "5": 137085, + "8": 53280 + }, + "rank_mass": 48165120, + "replicas": 740, + "roles": 2717280, + "scope": "Finite composed allocation and moment; fresh release is separate.", + "status": "PASS_T740_R1_FINITE", + "stock": { + "buffers": 91, + "group_order_times_physical_bit_length": 2647, + "live": 663040, + "namespaces": { + "centers": [ + 663040, + 663048 + ], + "coefficients": [ + 663547, + 663549 + ], + "tableau": [ + 663048, + 663456 + ], + "zero_buffers": [ + 663456, + 663547 + ] + }, + "payload": 2048, + "physical": 663549, + "reserve": 1512, + "stock_l2_bits": 1324 + } +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-CAP.json b/research/rank7-six-skip-cap-release/vendor/PR3042-CAP.json new file mode 100644 index 0000000000..f4c94b6241 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-CAP.json @@ -0,0 +1,124 @@ +{ + "basis_patterns": [ + { + "capacity": 8, + "count_per_replica": "672", + "widths": [ + 8 + ] + }, + { + "capacity": 32, + "count_per_replica": "115/4", + "widths": [ + 7, + 8, + 8, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "234", + "widths": [ + 4, + 9, + 9, + 9 + ] + }, + { + "capacity": 48, + "count_per_replica": "1341/20", + "widths": [ + 9, + 9, + 9, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "93/4", + "widths": [ + 9, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "144", + "widths": [ + 6, + 8, + 9, + 9 + ] + }, + { + "capacity": 32, + "count_per_replica": "18", + "widths": [ + 5, + 9, + 9, + 9 + ] + }, + { + "capacity": 16, + "count_per_replica": "35/4", + "widths": [ + 8, + 8 + ] + }, + { + "capacity": 16, + "count_per_replica": "1757/4", + "widths": [ + 7, + 9 + ] + }, + { + "capacity": 48, + "count_per_replica": "7619/20", + "widths": [] + } + ], + "cap_lower": "4324344875160696378107/2500000000000000000000000", + "cap_lower_decimal": "0.0017297379500642785512428", + "cap_upper": "17297379500642785512429/10000000000000000000000000", + "cap_upper_decimal": "0.0017297379500642785512429", + "idle_per_replica": { + "1": "234", + "3": "1341/20", + "48": "7619/20", + "5": "93/4" + }, + "inventory_per_call": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "local_per_call": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "patterns": 2551, + "rank_mass_identity": true, + "scenario": "final words of PR2979 plus declared restore edit list (R1, Stack2979)", + "status": "PASS_EXACT_RELAXATION_CAP", + "strict_patterns": 2539, + "tight_patterns": 12 +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-CLAIM.json b/research/rank7-six-skip-cap-release/vendor/PR3042-CLAIM.json new file mode 100644 index 0000000000..47a55a7f68 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-CLAIM.json @@ -0,0 +1,229 @@ +{ + "admitted_package_manifest_sha256": "2c367a7afa966a7952303364fbccd6332730e2d3ad48d2ef04a524f35daddb03", + "baseline_head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "baseline_kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 2969, + "baseline_status": "FINITE_NATIVE_OWNER_AND_MOMENT_CANDIDATE_OUTER_PENDING", + "calls": 666, + "complex_lower": "432434041596978996703/250000000000000000000000", + "declared_edits": { + "count": 2, + "edits_sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "previous_kappa": "0.0017290339826465135177169999999999999999999998999999999999999999999999", + "previous_pr": 2979 + }, + "fill_sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "fixed_inventory_cap": { + "cap_lower": "4324344875160696378107/2500000000000000000000000", + "cap_upper": "17297379500642785512429/10000000000000000000000000", + "realized": "below the fractional optimum by the recorded gap (check_cap.py); the cap basis is fractional at T74" + }, + "gain": "2850470819905554131/500000000000000000000000", + "helpers": 408, + "independent_inputs": 632, + "kappa": "17297361663879159868119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017297361663879159868119999999999999999999998999999999999999999999999", + "live_families": 66304, + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "native_receipt_sha256": "7e982591b1362efe5e8d03fd98f67ff4ef676dd8a5fa3ca765c8ef1370be7019", + "physical_families": 66813, + "previous_claims": { + "pr2942": { + "claim_file": "comparators/PR2942-CLAIM.json", + "gain": "108122601948463419/15625000000000000000000", + "head": "a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf", + "kappa": "17228163198632143279959999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2942 + }, + "pr2957": { + "claim_file": "comparators/PR2957-CLAIM.json", + "gain": "6018751317177815841/1000000000000000000000000", + "head": "b74b25f3ccc84c16e1a801d73b2f47e5ea764c78", + "kappa": "17237174150707381709709999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2957 + }, + "pr2966": { + "claim_file": "comparators/PR2966-CLAIM.json", + "gain": "28509469322319047/5000000000000000000000", + "head": "e62d3eb9005117d82a9babcfa937ecc53237c490", + "kappa": "17240342725234521774119999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2966 + }, + "pr2969": { + "claim_file": "allocation/baseline/CLAIM.json", + "gain": "2850470819905554131/500000000000000000000000", + "head": "e2ca469b08385d3d5e29a918d66dbefaf889e9f3", + "kappa": "17240352247481048785499999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2969 + }, + "pr2979": { + "claim_file": "comparators/PR2979-CLAIM.json", + "gain": "140436748280493819/200000000000000000000000", + "head": "be191346391661f4d35fc0d1508d0a6029572576", + "kappa": "17290339826465135177169999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2979 + } + }, + "profile": { + "1": 1637688, + "2": 474192, + "3": 159468, + "4": 71928, + "48": 28190, + "5": 13716, + "8": 5328 + }, + "release_receipt_sha256": "906d15db82f7b5b8938d1b760f54d9229dc7b6f2dbe84cc9286f2d1015e36743", + "replicas": 74, + "scope": "Conditional finite supplier/outer certificate for PR2979's words (mdumitrean: joint rank-7 end frames, five further paired extractions, fourteen PR2957 rewrites) with one declared literal restore edit (R1, Stack2979 / Jeremy Kothe) and PR2979's literal T74 allocation unchanged (paid profile re-derived). Inherited all-size/compiler/theorem hypotheses remain. No selected-frontier change or independent-human-review claim.", + "source_manifest_sha256": "130650ad8833f6df88528c560e4d1cfbae084f4b15a64788a332ddcaff472a17", + "stages": { + "stage1": { + "frame_edits": 139, + "groups": { + "A": { + "W": [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ], + "helpers": [ + 331, + 450, + 451, + 508, + 509 + ] + }, + "B": { + "W": [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ], + "helpers": [ + 299, + 448, + 449, + 484, + 485 + ] + }, + "C": { + "W": [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ], + "helpers": [ + 452, + 453, + 532, + 533 + ] + }, + "D": { + "W": [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ], + "helpers": [ + 454, + 455, + 556, + 557 + ] + }, + "V45": { + "W": [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ], + "helpers": [ + 249, + 251, + 265, + 267 + ] + } + }, + "kind": "joint codimension-2 end-frame lowering (frame-only)", + "record_sha256": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3" + }, + "stage2": { + "extractions": [ + { + "helper": 226, + "normal": 42, + "step": 1 + }, + { + "helper": 228, + "normal": 42, + "step": 2 + }, + { + "helper": 230, + "normal": 42, + "step": 3 + }, + { + "helper": 363, + "normal": 7, + "step": 4 + }, + { + "helper": 395, + "normal": 7, + "step": 5 + } + ], + "kind": "rank-8 paired input/output extractions" + }, + "stage3": { + "applier_sha256": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "count": 14, + "kind": "declared exactness-preserving gate rewrites (Jeremy Kothe, PR2957), re-addressed", + "rewrites_sha256": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d" + } + }, + "status": "CONDITIONAL_CANDIDATE_COMPLETE_FINITE_RELEASE", + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + }, + "zero_buffers": 91 +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-EDITS.json b/research/rank7-six-skip-cap-release/vendor/PR3042-EDITS.json new file mode 100644 index 0000000000..c2042a37bd --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-EDITS.json @@ -0,0 +1,2984 @@ +{ + "declared": { + "local_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "width_inventory": { + "4": 26, + "5": 2, + "6": 16, + "7": 52, + "8": 99, + "9": 213 + } + }, + "edits": { + "base": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ], + "extra": [ + { + "id": "R1_E42", + "new": [ + [ + "add", + 40, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 226, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 40, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 18, + 226, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 228, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 228, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 18, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 40, + 54, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 61, + 63, + 1, + 1, + [ + 256, + 128, + 64, + 35, + 16, + 11, + 5 + ] + ], + [ + "add", + 230, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 61, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 230, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 230, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "old": [ + [ + "add", + 18, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 18, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 226, + 18, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 18, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 34, + -2, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 22, + 108, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + 4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 228, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 108, + 228, + -4, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 40, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 45, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 54, + -2, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 61, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 63, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 92, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 103, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 108, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "scale", + 22, + 1, + -4, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 230, + 22, + 1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ], + [ + "add", + 22, + 230, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 16, + 10, + 4, + 1 + ] + ] + ], + "section": "restore", + "start": 162, + "stop": 188 + }, + { + "id": "R2_E7", + "new": [ + [ + "add", + 363, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 73, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + 1, + 4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 96, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "old": [ + [ + "add", + 59, + 73, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 59, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 363, + 59, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 59, + 363, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 96, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "scale", + 5, + 1, + -4, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 395, + 5, + 1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 5, + 395, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ], + [ + "add", + 96, + 395, + -4, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 5, + 3 + ] + ] + ], + "section": "restore", + "start": 190, + "stop": 203 + } + ] + } +} \ No newline at end of file diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-MANIFEST.json b/research/rank7-six-skip-cap-release/vendor/PR3042-MANIFEST.json new file mode 100644 index 0000000000..7018d721f5 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-MANIFEST.json @@ -0,0 +1,156 @@ +{ + ".gitattributes": "056f4f66161e333f3a8d4c20de323ca05599a7deac1aa02d47ba6f6b96335573", + "ALLOCATION-PINS.json": "7bb1494f220d2d5588e8563d1492f22678de8367ea981f1c2a4cc22d87a1cce0", + "CLAIM.json": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3", + "CREDITS.md": "8475f5e7c090e05196cfd6c2894516cbbedd5876f54193fea575d8064e23574e", + "EDIT-PINS.json": "11e15f1fd1f5ac263261c7834dcb2938da178b5c28070cc63b2fa7764ea0182a", + "NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "PINS.json": "79a82e455ef97c038169dd305fde230d935e007226083473b84413f74e49fdfe", + "README.md": "a7f24ba0b020afc394197ed2866f9958cfe6628c8b42bf84b09c98da0f681c85", + "RELEASE.json": "59e2e377b62aa785787f418b2bc196d48bc5824c5c4294af1387358642646bf5", + "SOURCES.json": "d5f3f498d4d34125bcaed14dafaceaff342223d511d1099993d5b217a147019c", + "TASK.json": "32c30a45ec317a55548c4f8d459d30ef9940c7787052e6a8b7b8ca2e31c18634", + "VERIFY.json": "5a07ba5f486929903fb736e96c3e1de562b2882876e64f9a32f5d657aae2b7f4", + "allocation/DISPATCH.json": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "allocation/FILL.json.gz": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "allocation/ORDER.json": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "allocation/PROFILE.json": "3245979197e965850eec803879f355a49738a60158cd7043fdc574e9fa810052", + "allocation/PROVIDERS.json": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0", + "allocation/SEARCH.json": "2ceb1f825cb68e44d17d4251f74c3975ae5122c845391c1ca8de2e564ac4246a", + "allocation/baseline/CLAIM.json": "656a4c93411b078753783513e2e71b1722a56e7b70120264a38118811982fa77", + "allocation/baseline/ORDER.json": "d559a1dcb83707724afc0310f6ef8e3a36ad6cda0a895ca6abae9d6f39a0fc76", + "allocation/baseline/PROFILE.json": "6de8ac1fd628cdd2afa5a43872da69c7dab9d7219bdc318f9db55fd8ccdb5eb2", + "allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "allocation/vendor/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "certificates/RELAX-CAP.json": "ef10b3d6481155eb3cd6f4ce3c82a6919fc5b5bce285d26cef39621989f22d9f", + "certificates/RELAX-STAGES.json": "0e5ec700a191b668ba3d4b6d675f5c047d264b9a5109fc55fa92961b3fcb7d68", + "check_allocation.py": "64b2bacd98728a25195d80e5be6c0374e24fba1400290edaafb895dcc5d54368", + "check_cap.py": "3f7901f4c1849074478df3c08ea98b792ae7325fd700948f01d80c11c9106893", + "comparators/PR2942-CLAIM.json": "011aaac80ad79f7f29dc429a672441bb6b3c21a68bbcb34c7a0d5f943c3c3c2e", + "comparators/PR2957-CLAIM.json": "a93e6c9e94bc9bf5664b5e23506dda9647fad1930e1eede66d5ba9f3718b598a", + "comparators/PR2966-CLAIM.json": "4d4c4800bf3bcb36d09021313b2712aebd4aa0830c74dda30991daf6851c220a", + "comparators/PR2979-CLAIM.json": "436e0d297cbdf195445d3697d496ac675e95210b79e70ce602a6a6667a4c6ce9", + "construction/STAGE-PRICES.json": "dfb7d06724bf95367f3fdb398f4828fc70f803d23030bc0eee0b00541457f546", + "construction/allocation/T37-FACE-MIX.json": "10598b7ea2e26fbd49db2b4d2f08122415fd6673b87fb7b458019d503ae60744", + "construction/allocation/T37-FLOW.json.gz": "765c6b774ca207f715dd5f579995700f4787c1f4eb92a7855bfc1424f683eca4", + "construction/allocation/T37-MODEL.json": "74849384ad2160f0402f6577e9d3ea849c21704abcf839af50f3353e141a4355", + "construction/allocation/T37-PATTERNS.json": "df09e4581d7ed73fa22253909197ceb26ced59333f50c008c822894a4082f0e4", + "construction/allocation/T37-SOLVER.json": "f56caa18e9638c568c57e699a8576fa6dcbdfe6ba54ae2da3fc8bc626168d863", + "construction/allocation/T74-CONTROLS.json": "0de2d067d957bbca2580566576030d4f10508b7827a0d83a0bd8c05f19b23bbf", + "construction/allocation/T74-OWNER-CHECK.json": "996234db3632983effc279a93cb5599a945688a3ea476fc9f88e3a714fb330be", + "construction/allocation/assemble.py": "57fcc8dd6f08b5557add7f34c0deb993574f71b3e565d6668085f1f65df5eccd", + "construction/allocation/controls.py": "9e10e5c21fab8ea2fdaf07ce92a141c4e6d63a7ef02d9de25bc9022ad1ae7998", + "construction/allocation/diag_lp.py": "59bfeb9586820f7b653370e20619760e23a4b170e4b7e14dc4e2abad9f5d9c61", + "construction/allocation/double.py": "8a89fafcd69cacb0a5a8d19a90d76f8740cf8f12585dc83796fcd8bc428dd94f", + "construction/allocation/fill17.py": "933be460381d65ea04a6e7f288f977ba22a7e4068b69494d65c38ccd7e5f4dbf", + "construction/allocation/providers_from_words.py": "8cf55c2859a626d86f21b447460321c19db92fec8e1f893b3cd37267f3b145fd", + "construction/allocation/round_mix.py": "0d0a423817b30fda9cceaa61b9bcc90e07710f9829e65098c9a31ed1734341bd", + "construction/records/derive_stage2.py": "f2518333cea351376ee094e8212b71ad753710d4038c55937a9e3bb212249f9e", + "construction/records/make_data.py": "b9528bcb26bc3c1a8e582032fa3899c79dc4cb463814dc6fea617fd83a5b4858", + "construction/records/make_prices.py": "5fcf593b5672b4f66cabd9d2bd5b4e843453248186d95794386331d801280b78", + "construction/search/codim2.py": "1dd77f4ceb0c4cf82ee5f3f4c04123724db09ebb0e7b9f856c4bd000d4e57531", + "construction/search/combine.py": "d06e041082f120b903937a8c7fdf2189eb42411330af625492ff5a24109b49d0", + "construction/search/deliver_l22.py": "b5f0a6ee2eaf1cbef95f0447efb08b75937e7e03c6d27d0b73d5c884c24a91b5", + "construction/search/final_l27.py": "e964d48e7b7705cc64a57bd42d81eb990d69606689349240e5a18155d08f7350", + "construction/search/lowerA.py": "1aba1edb5397701151b2c95afaf23cd8e675ddc48b5ccca1738bc0c5370e9a6c", + "construction/search/lowerA_joint.py": "eb0efbe0c40d063a606dc370362a8d3fe3f4f57877e2e79f63be940fe06ce41b", + "construction/search/realize.py": "6d524f4a1ce0a4bf77f8e5a859e46922334956688c9268dbea3004e3aea6898e", + "construction/search/vlower.py": "3052c96b4f00239fe679f460bbbad2b7271089b5aa73665cb92c052755143ec4", + "data/PARENT-base.json.gz": "54ca34c749e3228d7e2df3d8dbf7aa1568c2872490166997c5962f12fd03da35", + "data/PARENT-extra.json.gz": "eded756dfe8f411c3d1f80a3ac16516f0ea5dd6f9866728b2179b157630fa7b6", + "data/REWRITES-2957.json": "a37ade675876e4f5b00b33066c84f495fccd264863b7eb5d813837b1d01c3e7d", + "data/STAGE1-FRAME-EDITS.json": "5fbfce004330ebc1fbac8de264614fe295f1a074811b478db4892c3bc3852cd3", + "data/TRANSFORM-226.json": "1732a39728c068f9d663111c7876b4e0b96088f3dd3b8e6ff824551b5a711338", + "data/TRANSFORM-228.json": "82346e6a5173c4822e16b2dad06ca232111b6795a340079f9aceabe0098797c0", + "data/TRANSFORM-230.json": "8ad70d545695b5d2246fb9e09d46abcc1e42926c1161884f69b77f978a28f46d", + "data/TRANSFORM-363.json": "84d2a609739eb30d4d9356fb6f04b2ff32c8823a978d7a51db1ace1d6d2352cc", + "data/TRANSFORM-395.json": "065aa5d7713683942bc2156b543681857e33c6e2f30f32cba47e2cbb9d1bef69", + "data/WORD-base.json.gz": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "data/WORD-extra.json.gz": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "edits/EDITS.json": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "edits/FINAL-WORD-base.json.gz": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "edits/FINAL-WORD-extra.json.gz": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "edits/declared_edits.py": "d3e49b844e9522808a439d505487839addbd957c7d1055bb57fa00e32cbba7b8", + "edits/edits_review.py": "41734b21dfef4fe9c0917e6afcfb2d0652a4a55583f9cbc300af0ffc275af28c", + "evidence/ADAPTER-DERIVATION.json": "a6c42ad0c10713baecc65853108bd4ba8c2295ef7fd85ad03a80d23a6561485a", + "evidence/ADMISSION-RESULT.json": "7f4f43db039b6d0e1dad7ed6549e0c77a97450f3e347db7ee4b60924c61b1187", + "evidence/ADMISSION-STAGES.json": "7ff279bbae26a36e917cf8d29646a436a470c9c6f535e3af4d7d8443767bbe52", + "evidence/EDITS-DERIVATION.json": "f4244fcbf21f41c54c053fb0719c1afaadafe0a5305f061fac6baa04d6da26b7", + "evidence/EDITS-REVIEW.json": "5e45e0108ad21b47d534c607e4da9200ea4f76a103b0c854542d006b711cadbe", + "evidence/ENVIRONMENT.json": "23f2e3174612fd8ad04b5af4bab5b840d50c0c93d68d1eccc4d66a2f9df36896", + "evidence/FULL-NATIVE-RECEIPT.json": "7e982591b1362efe5e8d03fd98f67ff4ef676dd8a5fa3ca765c8ef1370be7019", + "evidence/FULL-NATIVE-RESULT.json": "13990ed299092d7c1b1e963e83bbff11d0c5a68650284e5bba997e13009905a4", + "evidence/FULL-REPLAY-RESULT.json": "9bd72aa02d4665f7f24a356fdd03d8da767234d0b1f4e773000b5cf1a874b070", + "evidence/FULL-REPLAY-STAGES.json": "06b4071f46edb76550d3dd9a1c62cdb879effa305f80156ca89d9fa699b01679", + "evidence/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/README.md": "2b6f99fc0d15d8575f30cff368aed0c2170da54135d7142641bdeceecb7ecdd5", + "evidence/RELEASE-RECEIPT.json": "906d15db82f7b5b8938d1b760f54d9229dc7b6f2dbe84cc9286f2d1015e36743", + "evidence/RUNTIME-PATCHES.json": "25a75bcbc9535bce28c14fbe2fdff6ab42ed7a8193da6d473258ebd53901315c", + "evidence/logs/admission-discovery.log.txt": "7323585286381c3a740f743bd8d34fbac261063475591750f2f6105da2b52b43", + "evidence/logs/admission-outer-check_ledger.py.log.txt": "c3a7a6c9d72696e898ec0e7ebb5327d4bcbb3796296c802fdd3cc52d4ea0ed76", + "evidence/logs/admission-outer-independent_check.py.log.txt": "f49a96248d35bbb371283a8e0f079783974a904c9f59f94b19eba156346cb87b", + "evidence/logs/admission-owners.log.txt": "748837990aea82c6fe4e65a6c342d29db8074c9f31fe59c24dbc0988c2e053eb", + "evidence/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/logs/admission-rebind.log.txt": "6fcad10d5896199b8a4b3d55e749a3c0d68c0ab709f55e54085de8326a04e7cf", + "evidence/logs/admission-release.log.txt": "805fce9a345ccdda3f35d6a902150f9c79e8156187999fb1e2adeaebd0d3b778", + "evidence/logs/complete-admission.log.txt": "f49b7c5a423df905b7639d736f092df2119f76c472c9e62d6a082ad5caf51752", + "evidence/logs/declared-edit-stage.log.txt": "e0d0595445e237ed99b78764aeb387fea1e7d4e1c5316fc78e49b2ebfc773de5", + "evidence/logs/derive-closed-adapters.log.txt": "e2e9b59cca255f95b2239ff3c9c0b7d5ec32308b7322cef7535ba4c399527bec", + "evidence/logs/export-pr2833.log.txt": "9064165a51df3c763c3ede7e4bb55ce4757e218eca0597fae78c2f9e7fd30030", + "evidence/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "evidence/pr2979/ADAPTER-DERIVATION.json": "abfe60c965953c567392b587cbcc4703f2f80fc60e267539251a1eac0f9db2f3", + "evidence/pr2979/ADMISSION-RESULT.json": "be9652312a88fd670eb09a4303679b4e875516d02a008ce90ccbca8a92e6b2ac", + "evidence/pr2979/ADMISSION-STAGES.json": "bf2fcb3012c65d861ccc4ba5950e5b97cbff31f603268afdb7e9ae2a0ac9696f", + "evidence/pr2979/ENVIRONMENT.json": "c6faaaa9b538ddbf0ea3c624bbe2f1c7e4074f8cb504d4bee0f3353f1e7f32a1", + "evidence/pr2979/FULL-NATIVE-RECEIPT.json": "6d27c89d5e3a2c7f28387e4b20c462b0dff6c9fa92aacdde715d4b29cc286d41", + "evidence/pr2979/FULL-NATIVE-RESULT.json": "ee10e7b8f2196b3bd28f5389b9be3372c216f3cfe67e00c7a2bcd130746ac364", + "evidence/pr2979/FULL-REPLAY-RESULT.json": "0293261edd3696408e1067df358644a7f43fd05f6c7b78e255aeac3f4a2530a2", + "evidence/pr2979/FULL-REPLAY-STAGES.json": "d8764bbbc029b13e20dc881783c44b74c689064d9ddf8286fc18371f2ec0d503", + "evidence/pr2979/OVERLAY-DERIVATION.json": "145a9491cca7b22f0d04cccb66795a7b6914a1ee415ecfc65e1db7b586573826", + "evidence/pr2979/RELEASE-RECEIPT.json": "473a5f8e048e45d7e83747077a18985ef87d58da370ca3f2fe5748a057ffdb2d", + "evidence/pr2979/RETAINED-BOOTSTRAP-RECEIPT.json": "ba9ef5709319ceb54928aed10cb250f3d018b3f654a2902c53df27d9e2e1157f", + "evidence/pr2979/RUNTIME-PATCHES.json": "6e4fe608caae2cdc28abc0ab772514d03ede2a4a50b06e9ede2853ab6889f218", + "evidence/pr2979/logs/admission-discovery.log.txt": "68845b7e19574ee2040677640848f0f7aaf71854250dfe0470dfae3ff09210b3", + "evidence/pr2979/logs/admission-outer-check_ledger.py.log.txt": "c56f8e0232d749e0ff33b76a8f9de18d28a7bb3abcd736ba69a4b167f2b5a824", + "evidence/pr2979/logs/admission-outer-independent_check.py.log.txt": "7eab2e50c0b03f058ae320c4791a0ea5a0ae3eae3393d29971663428ca79547a", + "evidence/pr2979/logs/admission-owners.log.txt": "dc4840d279e447e42af2ece9437cb92ab13c7f631440911ca5e8a676e3fa418c", + "evidence/pr2979/logs/admission-parent-lift.log.txt": "7b6249a123ca39fae7b7a6339dd9e8ae8777b081f4336418f2cc101704b70644", + "evidence/pr2979/logs/admission-rebind.log.txt": "6126af0a7935a1605ddad6074978494d462ed67cbd54be809ce13fcb32469d67", + "evidence/pr2979/logs/admission-release.log.txt": "d1e575ccd284596605baf38e5ed5b751cd5f506572ef9cfc578bd88d917b46a0", + "evidence/pr2979/logs/complete-admission.log.txt": "37584a0aed98b08f491b676ba0e4914518027f556495b1ae4e8a9a123d360b4f", + "evidence/pr2979/logs/derive-closed-adapters.log.txt": "d11d75855720cfa75a26f667a61467b5122a7b7ae5521030509bf1cbdd00a496", + "evidence/pr2979/logs/export-pr2833.log.txt": "0fa7e0c6a0f0e31c60aadd0fe2afa6841d046d3272a02d3dc873f999b8508654", + "evidence/pr2979/logs/export-pr2894.log.txt": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "evidence/pr2979/logs/four-kernel-stage.log.txt": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/pr2979/logs/fresh-current-native.log.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/pr2979/logs/fresh-retained-bootstrap.log.txt": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "evidence/pr2979/logs/paired-extension-stage.log.txt": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "evidence/pr2979/logs/parent-paired-stage.log.txt": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "evidence/pr2979/logs/preload-stage.log.txt": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "evidence/pr2979/logs/rank7-overlay-stage.log.txt": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "producer.py": "d4577cee26314b36b59723cc68df9b8895b22449cc15807c95f325f555c4da3a", + "reproduce.py": "576152d744078d5cb66cded265c189691403f73b277ce2ed0e80708d77629eda", + "run_registered.py": "3439d214a163223c2ca7b50562bfb24b284551d5c8a36f4cc74791f890d4dd4a", + "structure.py": "83f63b6d9a1a543ecfa2c98d479dbe4e7a1c3caf6fd1c3566123308efbc32e96", + "tools/audit_allocation_moment.py": "c632527ecf092f013862660dbd7f52b599a50b321a8aa88ddc45af0547e79cb5", + "tools/build_edits.py": "7292e18bbbcd2fabc87ed423e3d5d648d03709d0a061563087786ad0d57fb832", + "tools/build_overlay.py": "9d98ace9bffb37aeebd05b93ed386f73e6eee169d960e4956cf14a66e6852140", + "tools/derive_adapters.py": "5c06828151cd230add3e328b42dda72c4a2ed1075bd2902f38ee28727870bc84", + "tools/relax.py": "0fed1c56b50a2e6d44deeeb6db0f1c7e1f71b86d1747130e1a9202216249a728", + "tools/relax_exact.py": "baf1855d6095c951a90d19a0d8094bd33290519940b732e2b758c5647830f044", + "tools/root.py": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "tools/wordedit.py": "cae8ae0f5d7fb3387ec6922fe966068aae05e3a6d3586830d4361b650cfb3617", + "vendor/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/declared_rewrites.py": "2509f1335e47543f8814b42d6bf83032b30c5899b4f7cc62a6adc03f5138ae13", + "vendor/preload_move.py": "c8fda4674644fcd5cbf39b6645ce148a21daa90a998b678cbe51f970b78b0044", + "verify.py": "5c6bdd35c81d9a2b3a12e020874a5d32e8b0783a3c35bff7a28d070586003401", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "812c963df6434a370d1e8031af8d8d8e8acd1ae4ab36124edbbd8e3106ae86cf" +} diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-NOTICE b/research/rank7-six-skip-cap-release/vendor/PR3042-NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-NOTICE @@ -0,0 +1,28 @@ +research/rank7-joint-endframes +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Prepared with substantial AI assistance (Anthropic Claude, via Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #2942 (Marius-Paul Dumitrean, head +a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf, research/paired-extension-normal45): data/PARENT-base.json.gz and +data/PARENT-extra.json.gz (its data/WORD-*.json.gz), comparators/PR2942-CLAIM.json and tools/wordedit.py; PR #2917 +(Mason Hale, head 224bd5e56041c40078ff6b5fa7393733a215de5c, research/paired-helper-extension): structure.py (Jeremy +Diviney's PR2908 two-sided certificate checker), vendor/audit_local.py (PR2833's independent exact auditor, icekylinx +attribution), vendor/preload_move.py (Jeremy Kothe's PR2894 frame accounting and cleanup), allocation/ORDER.json, +allocation/DISPATCH.json and allocation/vendor/ (independent_owners.py: Tekalign's independent owner checker as vendored +by PR2839/PR2917; PLAN.json.gz, TEMPLATE.json.gz); PR #2957 (Jeremy Kothe, head b74b25f3ccc84c16e1a801d73b2f47e5ea764c78, +research/paired-extension-cap-fill-swaps): vendor/declared_rewrites.py (the pure applier of the fourteen declared +rewrites) and comparators/PR2957-CLAIM.json; PR #2966 (Jeremy Kothe, head e62d3eb9005117d82a9babcfa937ecc53237c490, +research/paired-extension-normal45-rewrites): comparators/PR2966-CLAIM.json; PR #2969 (Dugongue, head +e2ca469b08385d3d5e29a918d66dbefaf889e9f3, research/paired-swap-normal45): allocation/baseline/ (its CLAIM.json and its +allocation ORDER.json and PROFILE.json); and PR #2930 (head 81f3b5d12977eba09e06fbff729167d59faabe90): tools/relax.py, +tools/root.py, tools/relax_exact.py. +data/REWRITES-2957.json is Jeremy Kothe's PR2957 rewrite list, re-addressed to this package's stage-2 word with exact +preimages (every entry keeps a credit field). producer.py follows PR2917's producer.py (Mason Hale) for its paired steps; +verify.py, check_allocation.py, check_cap.py, run_registered.py and reproduce.py adapt our PR2942 versions of PR2917's and +PR2930's; tools/audit_allocation_moment.py is PR2917's exact moment auditor with only its authenticated baseline changed (to +the PR2969 headline); tools/derive_adapters.py generalizes PR2917's adapter derivation (PR2908, Jeremy Diviney); +tools/build_overlay.py follows the overlay conventions of PR2908's and PR2917's builders. construction/allocation/ retains +the flow model of PR2857/PR2843 (Yiyang Lu, Marius-Paul Dumitrean) as adapted for this allocation. All original notices of +the exported predecessor packages remain in force. + +Derived work (Apache-2.0): this package (`research/rank7-restore-carrier-skips`) builds on PR #2979 (Marius-Paul Dumitrean, head be191346, research/rank7-joint-endframes) and PR #3015 (Jeremy Kothe, jeremykothe2, research/rank7-joint-endframes-restore-edit), retained byte-identical except for the files named in README.md, plus two declared restore edit blocks (`R1_E42` and `R2_E7` in `edits/EDITS.json` and `edits/FINAL-WORD-*.json.gz`) and their re-derived certificates and complete fresh-native admission and release receipts by dcharb78, with AI assistance. PR #2979's own evidence is kept under evidence/pr2979/. diff --git a/research/rank7-six-skip-cap-release/vendor/PR3042-PROVIDERS.json b/research/rank7-six-skip-cap-release/vendor/PR3042-PROVIDERS.json new file mode 100644 index 0000000000..c0575e3903 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/PR3042-PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2433, + "2": 712, + "3": 232, + "4": 108, + "5": 18, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} diff --git a/research/rank7-six-skip-cap-release/vendor/cap_proof.py b/research/rank7-six-skip-cap-release/vendor/cap_proof.py new file mode 100644 index 0000000000..28f0995a69 --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/cap_proof.py @@ -0,0 +1,257 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact fixed-inventory cap and replica-divisibility certificate. + +The caller must authenticate the root arithmetic module and bind `certificate` +to the words' actual local profile and width inventory. This module checks the +fixed chronology-free pattern relaxation. It does not prove chronological +feasibility or any scalar/native/physical/outer admission obligation. +""" + +from fractions import Fraction +from itertools import product +from math import gcd + +Q = Fraction +WIDTHS = (4, 5, 6, 7, 8, 9) +CAPS = (8, 16, 32, 48) +BINS = (672, 448, 448, 448) +INVENTORY = (26, 2, 16, 52, 99, 213) +LOCAL = {1: 2445, 2: 706, 3: 232, 4: 108, 5: 18, 8: 8} +Q_ROW = (-3, -6, -12, 0, 0, 0, 1, 2, 3, 4) +TIGHT = ( + (8, (8,)), + (16, (8, 8)), + (16, (7, 9)), + (32, (9, 9, 9)), + (32, (8, 8, 8, 8)), + (32, (7, 8, 8, 9)), + (32, (7, 7, 9, 9)), + (32, (6, 8, 9, 9)), + (32, (5, 9, 9, 9)), + (32, (4, 9, 9, 9)), + (48, ()), + (48, (9, 9, 9, 9, 9)), +) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def patterns(): + """All 2,551 capacity-feasible count vectors; loops have fixed finite bounds.""" + result = [] + for capacity in CAPS: + for counts in product(*(range(capacity // width + 1) for width in WIDTHS)): + idle = capacity - sum(w * n for w, n in zip(WIDTHS, counts, strict=True)) + if idle >= 0: + result.append((capacity, counts, idle)) + need(len(result) == 2551, "changed pattern domain") + return result + + +def column(pattern): + capacity, counts, _ = pattern + return tuple(int(capacity == cap) for cap in CAPS) + counts + + +def inverse(matrix): + """Gauss-Jordan inversion over Q, explicitly restricted to the 10-row model.""" + need(len(matrix) == 10 and all(len(row) == 10 for row in matrix), "matrix shape") + rows = [ + [Q(value) for value in row] + [Q(i == j) for j in range(10)] + for i, row in enumerate(matrix) + ] + for col in range(10): + pivot = next((r for r in range(col, 10) if rows[r][col]), None) + need(pivot is not None, "singular basis") + rows[col], rows[pivot] = rows[pivot], rows[col] + divisor = rows[col][col] + rows[col] = [value / divisor for value in rows[col]] + for r in range(10): + if r != col: + multiple = rows[r][col] + rows[r] = [ + a - multiple * b for a, b in zip(rows[r], rows[col], strict=True) + ] + return [row[10:] for row in rows] + + +def basis_data(certificate, catalogue): + need( + set(certificate["inventory_per_call"]) == set(map(str, WIDTHS)), + "inventory keys", + ) + need( + tuple(Q(certificate["inventory_per_call"][str(w)]) for w in WIDTHS) + == INVENTORY, + "wrong inventory", + ) + need( + {int(r): Q(n) for r, n in certificate["local_per_call"].items()} == LOCAL, + "wrong local profile", + ) + entries = certificate["basis_patterns"] + need(len(entries) == 10, "wrong basis size") + basis, amounts = [], [] + for entry in entries: + widths = entry["widths"] + need(len(widths) <= 12 and all(w in WIDTHS for w in widths), "basis widths") + pattern = ( + entry["capacity"], + tuple(widths.count(w) for w in WIDTHS), + entry["capacity"] - sum(widths), + ) + need(pattern in catalogue, "infeasible basis pattern") + basis.append(pattern) + amounts.append(Q(entry["count_per_replica"])) + need(len(set(basis)) == 10 and all(x >= 0 for x in amounts), "basis feasibility") + columns = [column(p) for p in basis] + matrix = [[columns[k][r] for k in range(10)] for r in range(10)] + rhs = BINS + tuple(9 * n for n in INVENTORY) + need( + all( + sum(matrix[r][k] * amounts[k] for k in range(10)) == rhs[r] + for r in range(10) + ), + "basis does not supply complete counts", + ) + return basis, amounts, inverse(matrix), rhs + + +def reduced_cost(pattern, basis, basis_inverse): + """Exact coefficients of H_r in c_p - a_p^T B^-T c_B.""" + coefficients = {pattern[2]: Q(1)} if pattern[2] else {} + a = column(pattern) + for k, basic in enumerate(basis): + if basic[2]: + amount = -sum(a[j] * basis_inverse[k][j] for j in range(10)) + coefficients[basic[2]] = coefficients.get(basic[2], Q(0)) + amount + return {rank: value for rank, value in coefficients.items() if value} + + +def check_invariant(tight, rhs, amounts): + """A residue identity isolates the only idle-rank-3 tight pattern.""" + for pattern in tight: + value = sum(a * b for a, b in zip(Q_ROW, column(pattern), strict=True)) + is_five_nines = pattern[0] == 48 and pattern[1] == (0, 0, 0, 0, 0, 5) + need(value == 20 * is_five_nines, "tight-pattern invariant failed") + coefficient = sum(a * b for a, b in zip(Q_ROW, rhs, strict=True)) + need(coefficient == 1341 and gcd(coefficient, 20) == 1, "residue coefficient") + need( + all((20 * x).denominator == 1 for x in amounts), + "20 replicas do not integralize the displayed basis", + ) + return { + "identity": "20*N_[9,9,9,9,9]@48 = 1341*T", + "cap_requires_T_multiple_of": 20, + "first_multiple_of_74": 74 * 20 // gcd(74, 20), + "scope": "Pattern integrality; chronological sufficiency is not asserted.", + } + + +def verify_cap(certificate, root_tools): + """Recertify the complete relaxation and strictness on the entire root bracket.""" + catalogue = patterns() + basis, amounts, basis_inverse, rhs = basis_data(certificate, catalogue) + lower, upper = Q(certificate["cap_lower"]), Q(certificate["cap_upper"]) + need( + 0 < lower < upper <= Q(1, 100) and upper - lower <= Q(1, 10**25), "cap bracket" + ) + profile = {rank: Q(9 * amount) for rank, amount in LOCAL.items()} + idle = {} + for pattern, amount in zip(basis, amounts, strict=True): + if pattern[2]: + profile[pattern[2]] = profile.get(pattern[2], Q(0)) + amount + idle[pattern[2]] = idle.get(pattern[2], Q(0)) + amount + need( + {int(r): Q(n) for r, n in certificate["idle_per_replica"].items()} == idle, + "stored idle differs from primal basis", + ) + need(sum(r * n for r, n in profile.items()) == 65088, "rank mass") + need( + root_tools.moment(profile, lower, 896)[1] + < 1 + < root_tools.moment(profile, upper, 896)[0], + "unproved cap root bracket", + ) + intervals = { + rank: (root_tools.H(rank, lower)[0], root_tools.H(rank, upper)[1]) + for rank in range(1, 49) + } + tight, slacks = [], [] + for pattern in catalogue: + coefficients = reduced_cost(pattern, basis, basis_inverse) + if not coefficients: + tight.append(pattern) + else: + slack = sum( + v * intervals[r][0 if v > 0 else 1] for r, v in coefficients.items() + ) + need(slack > 0, "reduced cost is not strictly positive on cap bracket") + slacks.append(slack) + named = { + (cap, tuple(w for w, n in zip(WIDTHS, counts, strict=True) for _ in range(n))) + for cap, counts, _ in tight + } + need(named == set(TIGHT) and len(slacks) == 2539, "tight domain differs") + invariant = check_invariant(tight, rhs, amounts) + return { + "idle_per_replica": {str(r): str(n) for r, n in sorted(idle.items())}, + "patterns": len(catalogue), + "strict_patterns": len(slacks), + "tight_patterns": len(tight), + "minimum_slack_lower": str(min(slacks)), + "cap_lower": str(lower), + "cap_upper": str(upper), + "invariant": invariant, + } + + +def unit_log_interval(y): + """Three atanh terms and a geometric tail for 1 <= y <= 2.""" + need(Q(1) <= y <= Q(2), "unit log argument") + z = (y - 1) / (y + 1) + lower = 2 * sum(z ** (2 * j + 1) / (2 * j + 1) for j in range(3)) + return lower, lower + 2 * z**7 / (7 * (1 - z * z)) + + +def prove_exchange_sign(): + """For 0 < b <= 1/100, 20H1+17H3-15H5-10H14+3H48 < 0.""" + l2, u2 = unit_log_interval(Q(2)) + a3, b3 = unit_log_interval(Q(3, 2)) + a5, b5 = unit_log_interval(Q(5, 4)) + a14, b14 = unit_log_interval(Q(7, 4)) + logs = { + 2: (l2, u2), + 3: (l2 + a3, u2 + b3), + 5: (2 * l2 + a5, 2 * u2 + b5), + 14: (3 * l2 + a14, 3 * u2 + b14), + } + limits = { + 2: (Q(69, 100), Q(7, 10)), + 3: (Q(109, 100), Q(11, 10)), + 5: (Q(0), Q(161, 100)), + 14: (Q(0), Q(66, 25)), + } + for rank, (lower, upper) in logs.items(): + need(limits[rank][0] < lower <= upper < limits[rank][1], "log bound") + need( + 4 * logs[2][0] + logs[3][0] > Q(77, 20) + and 4 * logs[2][1] + logs[3][1] < Q(39, 10), + "log48 bounds", + ) + need(20 + 51 - 75 - 140 + 144 == 0, "f(0) differs") + derivative_upper = ( + 75 * Q(161, 100) + + 140 * Q(66, 25) + - 51 * Q(109, 100) * Q(989, 1000) + - 144 * Q(77, 20) * Q(961, 1000) + ) + need(derivative_upper == Q(-9740691, 100000) < 0, "derivative sign") + return { + "delta": {1: 20, 3: 17, 5: -15, 14: -10, 48: 3}, + "saving_interval": "0 < b <= 1/100", + "factored_f_derivative_upper": str(derivative_upper), + } diff --git a/research/rank7-six-skip-cap-release/vendor/lift.py b/research/rank7-six-skip-cap-release/vendor/lift.py new file mode 100644 index 0000000000..717067dfce --- /dev/null +++ b/research/rank7-six-skip-cap-release/vendor/lift.py @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Ten interleaved copies and a sparse, preimage-bound allocation journal.""" + +from collections import Counter, defaultdict + +COPIES = 10 +BASE_T = 74 +HELPERS = 408 +BASE_ROLES = 9 * BASE_T * HELPERS +MAX_EDITS = 2000 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def row_at(base, index): + need(type(index) is int and 0 <= index < COPIES * BASE_ROLES, "lift row index") + copy, original = divmod(index, BASE_ROLES) + time, helper, owner, child, port, offset = base[original] + return [COPIES * time + copy, helper, owner + BASE_T * copy, child, port, offset] + + +def patch(base, journal): + need(len(base) == BASE_ROLES, "base role count") + need(journal.get("copies") == COPIES, "journal lift multiplicity") + edits = journal.get("edits") + need(type(edits) is list and 0 < len(edits) <= MAX_EDITS, "journal size") + result = {} + for entry in edits: + need(type(entry) is list and len(entry) == 3, "edit shape") + index, before, after = entry + need(type(index) is int, "journal integer index") + need(index not in result, "duplicate journal index") + need(before == row_at(base, index), "journal preimage") + need(type(after) is list and len(after) == 6, "replacement row shape") + need(all(type(x) is int for x in after), "replacement integers") + need(after[:2] == before[:2], "fixed call/helper identity") + result[index] = after + return result + + +class Rows: + """Bounded streaming literal witness, in copy-major source-row order.""" + + def __init__(self, base, edits): + need(len(base) == BASE_ROLES, "stream base count") + self.base, self.edits = base, edits + + def __len__(self): + return COPIES * BASE_ROLES + + def __iter__(self): + for index in range(len(self)): + yield self.edits[index] if index in self.edits else row_at(self.base, index) + + +def chronology(order, dispatch): + need(len(order) == len(dispatch) == 9 * BASE_T, "base chronology size") + lifted_order, lifted_dispatch = [], {} + for stage, owner in order: + for copy in range(COPIES): + call = (stage, owner + BASE_T * copy) + lifted_order.append(list(call)) + lifted_dispatch[call] = dispatch[stage, owner] + return lifted_order, lifted_dispatch + + +def destination_window(key, windows): + owner, child, port = key + need(0 <= owner < COPIES * BASE_T and 0 <= port < 112, "destination bounds") + copy, original = divmod(owner, BASE_T) + need((original, child) in windows, "destination child") + capacity, lower, upper = windows[original, child] + lower = -1 if lower == -1 else COPIES * lower + copy + return capacity, lower, COPIES * upper + copy + + +def bin_members(base, index, key, edits): + copy, owner = divmod(key[0], BASE_T) + members = {} + for original in index.get((owner, key[1], key[2]), []): + global_index = copy * BASE_ROLES + original + if global_index not in edits: + members[global_index] = row_at(base, global_index) + for global_index, row in edits.items(): + if tuple(row[2:5]) == key: + members[global_index] = row + return members + + +def check_bin(key, members, widths, windows): + capacity, lower, upper = destination_window(key, windows) + mask, pattern = 0, [] + for row in members.values(): + time, helper, _, _, _, offset = row + need(lower < time <= upper, "changed source window") + width = widths[time // COPIES][helper] + need(0 <= offset and offset + width <= capacity, "changed capacity") + bits = ((1 << width) - 1) << offset + need(mask & bits == 0, "changed bin overlap") + mask |= bits + pattern.append(width) + used = mask.bit_count() + need(mask == (1 << used) - 1, "changed compact prefix") + return capacity - used, (capacity, tuple(sorted(pattern))) + + +def affected_calls(base, edits, families): + times = {row[0] for row in edits.values()} + need(len(times) <= MAX_EDITS, "affected call count") + for time in times: + original, copy = divmod(time, COPIES) + occupied = set() + for helper in range(HELPERS): + index = copy * BASE_ROLES + original * HELPERS + helper + row = edits[index] if index in edits else row_at(base, index) + family = row[2], families[row[3]], row[4] + need(family not in occupied, "changed same-call physical family") + occupied.add(family) + return len(times) + + +def differential(base, edits, widths, windows, families): + index = defaultdict(list) + for original, row in enumerate(base): + need(row[:2] == [original // HELPERS, original % HELPERS], "base row ordering") + index[tuple(row[2:5])].append(original) + keys = {tuple(row_at(base, i)[2:5]) for i in edits} + keys.update(tuple(row[2:5]) for row in edits.values()) + need(len(keys) <= 2 * MAX_EDITS, "affected bin count") + delta, pattern_delta = Counter(), Counter() + for key in sorted(keys): + before = bin_members(base, index, key, {}) + after = bin_members(base, index, key, edits) + old_idle, old_pattern = check_bin(key, before, widths, windows) + new_idle, new_pattern = check_bin(key, after, widths, windows) + if old_idle: + delta[old_idle] -= 1 + if new_idle: + delta[new_idle] += 1 + pattern_delta[old_pattern] -= 1 + pattern_delta[new_pattern] += 1 + return { + "affected_bins": len(keys), + "affected_calls": affected_calls(base, edits, families), + "idle_delta": {rank: count for rank, count in sorted(delta.items()) if count}, + "pattern_delta": [ + [cap, list(ws), n] for (cap, ws), n in sorted(pattern_delta.items()) if n + ], + } diff --git a/research/rank7-six-skip-cap-release/verify.py b/research/rank7-six-skip-cap-release/verify.py new file mode 100644 index 0000000000..9ef285b960 --- /dev/null +++ b/research/rank7-six-skip-cap-release/verify.py @@ -0,0 +1,159 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Source-bound finite verification of the six-skip/T740 composition. + +Jeremy Diviney with substantial OpenAI Codex assistance. The exact frame, +operator, owner, interval arithmetic, lift and cap engines are retained from +the credited predecessors. New here is their binding to this composition. +""" +import argparse +import collections +import contextlib +import copy +from fractions import Fraction as Q +import gzip +import hashlib +import io +import json +from pathlib import Path +import tempfile +import types + +P=Path(__file__).resolve().parent +ROOT=P.parents[1] +MAIN=ROOT/'research/rank7-joint-endframes' +LOCAL={1:2433,2:712,3:232,4:108,5:18,8:8} +IDLE={1:173160,3:49617,5:17205,48:281903} +PROFILE={1:16376940,2:4741920,3:1594737,4:719280,5:137085,8:53280,48:281903} + +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + raw=p.read_bytes() + return json.loads(gzip.decompress(raw) if p.suffix=='.gz' else raw) +def authenticate(): + paths=list(P.rglob('*')) + need(not any(p.is_symlink() for p in paths),'regular package files') + actual={p.relative_to(P).as_posix():sha(p) for p in paths if p.is_file() and p!=P/'MANIFEST.json'} + need(actual==read(P/'MANIFEST.json'),'complete published package inventory') + for path,expected in read(P/'SOURCE-PINS.json').items():need(sha(ROOT/path)==expected,'external source '+path) + for r in read(P/'VENDOR.json'):need(sha(P/r['path'])==r['sha256'],'vendor source '+r['path']) +def load(p,name): + m=types.ModuleType(name);m.__file__=str(p) + exec(compile(p.read_bytes(),str(p),'exec'),m.__dict__) + return m + +def apply_journal(fill,journal): + """PR3018 journal semantics, following Petalas's PR3021 apply_exchange.""" + rows=[r.copy() for r in fill['rows']];seen=set() + need(len(rows)==271728 and len(journal['edits'])==103,'complete base and journal') + for i,before,after in journal['edits']: + need(type(i)is int and 0<=iprevious,'strict improvement over PR3042') + bad=copy.deepcopy(journal);bad['edits'][0][1][0]+=1 + controls.append(rejection(lambda:apply_journal(base,bad),'changed journal preimage')) + controls.append(rejection(lambda:stock(buffers=90),'omitted private buffer')) + controls.append(rejection(lambda:stock(payload=1511),'insufficient payload')) + badprofile=PROFILE.copy();badprofile[1]-=1 + controls.append(rejection(lambda:root.kappa_from_profile(badprofile,740),'omitted paid child')) + return dict(status='PASS_SIX_SKIP_T740_FINITE',words=checks,owners=owner,stock=actual_stock,materialized=materialized, + profile=PROFILE,root=[str(lo),str(hi)],packing_cap=cap_result,realized_cap_fraction='1 (exact same moment profile)', + kappa=str(headline),baseline_kappa=str(previous),gain=str(headline-previous),controls=controls, + scope='Finite exact word/geometry/moment/cap checks. Stored release binding is separate; inherited source/native/compiler/physical/all-size hypotheses remain.') + +def main(): + p=argparse.ArgumentParser(description=__doc__);p.add_argument('--write',type=Path);p.add_argument('--finite-only',action='store_true');a=p.parse_args() + result=json.loads(json.dumps(finite(),sort_keys=True)) + if a.write:a.write.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else:need(result==read(P/'evidence/FINITE.json'),'committed finite receipt') + if not a.finite_only: + from verify_release import check + check(result) + print(result['status'],result['kappa'],'controls',len(result['controls']),flush=True) + +if __name__=='__main__':main() diff --git a/research/rank7-six-skip-cap-release/verify_release.py b/research/rank7-six-skip-cap-release/verify_release.py new file mode 100644 index 0000000000..58a4161d34 --- /dev/null +++ b/research/rank7-six-skip-cap-release/verify_release.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Check stored release bindings; this does not rerun native or outer stages. + +The receipt-binding pattern follows Nick Petalas's PR3030. The scientific +engines and actual release evidence are separately identified in the package. +""" +import copy +import gzip +import hashlib +import json +from fractions import Fraction as Q +from pathlib import Path + +P=Path(__file__).resolve().parent +E=P/'evidence' +SOURCE='130650ad8833f6df88528c560e4d1cfbae084f4b15a64788a332ddcaff472a17' +STAGES=['export-pr2894','export-pr2833','four-kernel-stage','preload-stage','parent-paired-stage','paired-extension-stage','rank7-overlay-stage','declared-edit-stage','derive-closed-adapters','fresh-current-native','complete-admission'] + +def need(ok,why): + if not ok:raise ValueError(why) +def read(p):return json.loads(p.read_bytes()) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() + +def validate(records,finite,bindings,invoice,materialized,outer): + full,admission,release,native=records + need(full['status']=='PASS_SIX_SKIP_T740_COMPLETE_RELEASE','composition release') + need(admission['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE','complete admission') + need(release['status']=='PASS_RELEASE','complete outer release') + need(full['admission_sha256']==bindings['admission'],'admission binding') + need(full['release_receipt_sha256']==admission['release_receipt_sha256']==bindings['release'],'release binding') + need(full['native_receipt_sha256']==admission['native_receipt_sha256']==bindings['native'],'native binding') + need(admission['fill_sha256']==materialized['sha256'],'actual admitted gzip input') + need(materialized['payload_sha256']==finite['materialized']['fill_payload_sha256'],'literal checked fill payload') + for key in ['order_sha256','dispatch_sha256']: + need(admission[key]==materialized[key]==finite['materialized'][key],'literal allocation '+key) + need(admission['source_manifest_sha256']==native['manifest_sha256']==full['source_manifest_sha256']==SOURCE,'same six-skip source') + need(native['status']=='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' and native['fresh_current_provider_count']==2,'two fresh current native providers') + for tag in ['base','extra']:need(native['providers'][tag]['word_sha256']==sha(P/f'words/{tag}.json.gz'),'native literal word '+tag) + need(full['fresh_retained_bootstrap'] is False and native['fresh_retained_parent'] is False and native['reused_retained_parent'] is True,'explicit authenticated retained reuse') + need(native['reused_retained_native_count']==2 and native['fresh_retained_native_count']==0,'retained cache accounting') + need(admission['replicas']==740,'T740 admission') + expected={int(r):n for r,n in finite['profile'].items()} + need({int(r):n for r,n in admission['profile'].items()}==expected,'complete admitted bill') + need(admission['package_manifest_sha256']==release['manifest_sha256'],'same released package') + endpoint=Q(finite['kappa']) + need(endpoint==Q(full['kappa'])==Q(admission['kappa'])==Q(release['kappa_decimal'])==Q(outer['kappa_rational'])==Q(outer['kappa']),'same modern outer endpoint') + need(Q(full['baseline_kappa'])==Q(finite['baseline_kappa']) and Q(full['gain'])==Q(finite['gain']),'same strict comparison') + need(Q(finite['baseline_kappa'])