diff --git a/research/t740-six-skip-precision30/PRECISION-EDITS.json b/research/t740-six-skip-precision30/PRECISION-EDITS.json new file mode 100644 index 0000000000..25716ba80a --- /dev/null +++ b/research/t740-six-skip-precision30/PRECISION-EDITS.json @@ -0,0 +1,26 @@ +[ + { + "new": "PRECISION = dict(endpoint_digits=30, grid_digits=24, margin_digits=34, bootstrap_steps=12)", + "old": "PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12)" + }, + { + "new": "dict(b=str(C-Q(1,10**110)), b_above_endpoint=str(C+Q(1,10**30)),", + "old": "dict(b=str(C-Q(1,10**104)), b_above_endpoint=str(C+Q(1,10**24))," + }, + { + "new": "kappa == C-Q(1,10**76)-Q(1,10**52)", + "old": "kappa == C-Q(1,10**70)-Q(1,10**46)" + }, + { + "new": "Endpoint precision30;", + "old": "Endpoint precision24;" + }, + { + "new": "kappa=C-10^-76-10^-52 exactly; same fixed-grid-maximum proof at precision30.", + "old": "kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24." + }, + { + "new": " patch('code/assemble.py', [(\" if DISCOVER:b=Q(M.certify(H,73,owner['live'],False)['lower']);conservative_b=Q(M.certify(H,73,owner['live'],True)['lower'])\", \" def fine_endpoint(bad):\\n digits=SPEC['outer_refinement']['endpoint_digits']\\n seed=Q(M.certify(H,73,owner['live'],bad)['lower'])\\n if digits<=24:return seed\\n grid=10**digits;left=int(seed*grid);right=left+10**(digits-24)\\n while right-left>1:\\n mid=(left+right)//2\\n lo,hi=FC.moment('fine_mercator',H,73,owner['live'],Q(mid,grid),bad)\\n if hi<1:left=mid\\n elif lo>1:right=mid\\n else:raise ArithmeticError('fine root enclosure exhausted; no endpoint accepted')\\n return Q(left,grid)\\n if DISCOVER:b=fine_endpoint(False);conservative_b=fine_endpoint(True)\")])\n spec['outer_refinement'] = PRECISION", + "old": " spec['outer_refinement'] = PRECISION" + } +] diff --git a/research/t740-six-skip-precision30/PROOF.md b/research/t740-six-skip-precision30/PROOF.md new file mode 100644 index 0000000000..799549d7d9 --- /dev/null +++ b/research/t740-six-skip-precision30/PROOF.md @@ -0,0 +1,81 @@ +# Scope and exact refinement + +This is an arithmetic refinement of Petalas's PR3054, not a changed supplier +or an independent proof of the inherited multiplication theorem. + +The complete paid profile is + +```text +{1:16376940, 2:4741920, 3:1594737, 4:719280, + 5:137085, 8:53280, 48:281903}. +``` + +For `T=740`, `W=896T`, its moment is + +`M(b) = sum_r n_r r (73/r)^b / (73W)`. + +All counts are positive and all ranks are below 73, so the moment is strictly +increasing. Its complete rank mass is `65088T = 48165120`. The retained +rational engines separately certify `M(C30)<1 0. +``` + +The gain is approximately `8.95823e-25`. It is numerically tiny. Increasing +the endpoint precision changes the point being certified, not the recursive +profile, native words, ordering, dispatch or stock. There is no claim of a +runtime improvement, a new packing mechanism or new independent verification +coverage merely from evaluating more digits. + +# Completion and privacy boundaries + +The reproduction first requires the original complete PR3054 result, every +successful stage's exact log digest, the unchanged source inventories, both +fresh native providers and the actual terminal release. It freshly rederives +the original admission adapter and compares its complete bytes. The five +declared precision edits and the fine-grid selector correction are applied; +the full original admission and +modern outer release run again. Source/native/fill/order/dispatch/profile +bindings must agree, and the actual released point must equal `kappa30` and +strictly exceed the actual completed baseline. + +The selector correction bisects the requested grid using the retained fine +moment engine. The original coarse selector alone cannot identify a 30-digit +endpoint. Both original acceptance and adjacent-point rejection checks remain. +The local checkpoint reuses authenticated successful nomination geometry, +then reruns assembly and the complete strict release; its evidence records +that scope. The fresh reproduction recipe reruns the nomination prefix too. + +Evidence sealing is separate. It verifies both completed admissions and their +terminal manifest/hash relations. Publication projects only the terminal +status, exact point and manifest, omitting machine timing. These projections +are labelled as projections; they are not represented as unchanged original +certificates. The original receipts remain unchanged in the external work +directories, with their full digests recorded. The actual complete outer +ledger and declared source derivation are copied unchanged. Registered finite +verification checks their hashes, all 63 positive outer margins, all 17 +original rejection controls, exact gain and explicit completion flags. + +No selected-frontier adoption, independent human review, formal-kernel proof +or discharge of inherited physical/compiler/precision/analytic hypotheses is +claimed. diff --git a/research/t740-six-skip-precision30/README.md b/research/t740-six-skip-precision30/README.md new file mode 100644 index 0000000000..8398e576a5 --- /dev/null +++ b/research/t740-six-skip-precision30/README.md @@ -0,0 +1,38 @@ +# T740 six-skip precision refinement + +**Complete baseline and refined strict releases passed locally.** + +Released conditional kappa is `0.001729737950064278551242895823 - 10^-52 - 10^-76`, approximately `8.95823e-25` above PR3054. This is a tiny rounding refinement of the same construction, not a new native or packing mechanism. Every recursive child, 91 buffers and 663,549 physical families remains charged. + +Both credited rational moment engines accept the proposed endpoint and reject the next 30-digit point and omitted rank-1/rank-48 costs. Full verification requires a completed unmodified PR3054 replay before the changed admission, which explicitly reuses that authenticated unchanged native cache. The recipe freshly rederives the original adapter and checks its exact bytes, then applies only the five precision edits and the fine-selector correction with all assertion/check counts preserved. Every original full admission and outer predicate remains mandatory. + +First run `research/rank7-t740-carrier-skips/reproduce.py` as documented by PR3054. Then run `python3.12 -B research/t740-six-skip-precision30/reproduce.py --baseline-work BASELINE --work FRESH_OUTPUT`. Inputs must be outside the package; source/cache are read-only. Full replay uses Python 3.12.3 and this package's requirements-full.txt: NumPy 1.26.4, SciPy 1.15.3, SymPy 1.14.0, mpmath 1.3.0 and gmpy2 2.3.2. These differ from the predecessor's published environment; all original scientific predicates remain unchanged. Registered finite replay is `python3.12 -B scripts/research_package.py --package research/t740-six-skip-precision30`; it requires sealed evidence and does not rerun the native chains. + +For a slower machine, the reproducible baseline entry point is +`python3.12 -B research/t740-six-skip-precision30/baseline.py --repo FULL_GIT_REPO --work BASELINE`. +It changes only the outer complete-admission wall-time allowance from 1,800 +to 7,200 seconds. Every scientific command, source predicate, input domain, +stage log and final completion check remains the predecessor's implementation. + +The local continuation authenticates and reuses the successful nomination geometry prefix after correcting the endpoint selector. It reruns assembly, freeze and independent checks, then runs the complete strict supplier and outer release freshly. `checkpoint.py` records this scope explicitly; `reproduce.py` provides the fresh end-to-end recipe. + +The exact raw local receipts remain private. Any eventual evidence projections must identify omitted machine metadata explicitly; no projected receipt is described as the unchanged original certificate. + +The inherited supplier summary contains a historical `controller=15` field. +Sealing must read the actual completed controller audit, require its exact +25 named rejected controls in both releases, and disclose the stale summary +separately. No predecessor receipt or predicate is corrected in place. + +After both full replays pass, seal evidence with +`python3.12 -B research/t740-six-skip-precision30/seal.py --baseline-work BASELINE --work FRESH_OUTPUT`. +The sealer rechecks both completed admissions, their stage/log digests, exact +source derivation and terminal receipt/manifest bindings before publishing +the scientific projections. It neither changes the original receipts nor +accepts preflight/discovery-only results. The raw external workspaces must +remain available for this check. + +Credit Nick Petalas/PR3054/3030/3024, dcharb78/PR3042, Jeremy Kothe/PR3015, Marius-Paul Dumitrean/PR2979, dataisfire/PR2161/2180/2168/2184 and the retained native/geometry/outer lineage. Apache-2.0. Substantial OpenAI Codex assistance. No independent human or formal-kernel review claimed. Source notices remain unchanged. All inherited all-size/compiler, physical backing/routing, dirty-state, precision/tape, caller, analytic-transfer and universal block-energy hypotheses remain. The selected frontier is unchanged. + +## Open next questions + +A material increase requires a changed paid mechanism outside the established fixed-word frame and packing optima. Name its actual producer/consumer boundary and complete bill before another search. Merely printing more digits is not new verification coverage. diff --git a/research/t740-six-skip-precision30/SOURCES.json b/research/t740-six-skip-precision30/SOURCES.json new file mode 100644 index 0000000000..ef9ec5814c --- /dev/null +++ b/research/t740-six-skip-precision30/SOURCES.json @@ -0,0 +1,600 @@ +{ + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "files": [ + { + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "path": "certificates/selected-result.json", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "path": "docs/research/agent-task-catalog.json", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "usage": "provenance" + }, + { + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "path": "research/complex-local-word-ceiling/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "usage": "input" + }, + { + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "usage": "input" + }, + { + "git_blob": "8d4fd644d60ba2c98106dc770803b647afdf0963", + "path": "research/rank7-joint-endframes/allocation/FILL.json.gz", + "sha256": "c2136be9434cda511a1a8a44d98f9f72ea5376830a8426674253b4ee351c4c39", + "usage": "input" + }, + { + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "usage": "input" + }, + { + "git_blob": "e1d99e12cfa3ac8375984d85c0b040dc36ea1312", + "path": "research/rank7-joint-endframes/allocation/PROVIDERS.json", + "sha256": "f2edb7922f3029a5d607437e737775ff3371bca49ebab62e5e2495d16d3bf573", + "usage": "input" + }, + { + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "usage": "input" + }, + { + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "usage": "input" + }, + { + "git_blob": "16013201b19054f7e45398ecf10af74c9c6a9114", + "path": "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "usage": "input" + }, + { + "git_blob": "14de38f85eedf4a96500173576184a439348328c", + "path": "research/rank7-joint-endframes/certificates/RELAX-CAP.json", + "sha256": "b272680de5842f7fd5f442cd0aeadfd317fe6af266ddee1a1e0738a919ba856e", + "usage": "input" + }, + { + "git_blob": "d9aa96a93fea5f7395e7783aef0bc117c0a0ae89", + "path": "research/rank7-joint-endframes/data/WORD-base.json.gz", + "sha256": "abaf67bfcb257528658c906b612f57025617592bd7889828f92b97a5f4f4300d", + "usage": "input" + }, + { + "git_blob": "74f6cb64595c21f7726ae77e69437868620bdcee", + "path": "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "sha256": "e0eaf64c4d5d324693d43889bce1b9e53e8da00402105c8c978fd102f208bed7", + "usage": "input" + }, + { + "git_blob": "bd6dc2eb4e5013625d17cc08461b67622bcfed69", + "path": "research/rank7-joint-endframes/tools/root.py", + "sha256": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "usage": "input" + }, + { + "git_blob": "009a4747f717b71c88321b786027a5766cf51c76", + "path": "research/rank7-t740-carrier-skips/.gitattributes", + "sha256": "5bf0e0ffcadbc7665285c27a72de32b52771116703f061e57fff3a3fb28fe998", + "usage": "input" + }, + { + "git_blob": "94acc6787987e95b32a2e515cbd7252732efa0ce", + "path": "research/rank7-t740-carrier-skips/ADAPTED.json", + "sha256": "b77072f329c8bb4b361d5461dbd696a5076fbd83e2ae35a7556253117ca36314", + "usage": "input" + }, + { + "git_blob": "d81697174f9b69f3fd1f756b3fce334182d57f6d", + "path": "research/rank7-t740-carrier-skips/ENGINEERING.md", + "sha256": "327a22672d56959a4015a51b0afea1f9b74eff1d021fce90858d24ffdda8c06c", + "usage": "input" + }, + { + "git_blob": "97729fe965c5686dabade5b5e857f4178d201a44", + "path": "research/rank7-t740-carrier-skips/GIT-SOURCES.json", + "sha256": "1b851c6d44939d88f3d85c55f63c82f3867f45c13e84cccce8de852a2192339a", + "usage": "input" + }, + { + "git_blob": "7c6cf7c0187e833db48d8cea3a783b5fbf4f0b04", + "path": "research/rank7-t740-carrier-skips/PINS.json", + "sha256": "67ac1377259fa68641779e55a76149a73757a1cd5b7c6a3c4e8f955fd33ad093", + "usage": "input" + }, + { + "git_blob": "469e1f8404460c81d5abc779148e0aabfa3e3609", + "path": "research/rank7-t740-carrier-skips/README.md", + "sha256": "bc1553112158df02a46777ef8d4cb51a4548a736fd155d50f879ac52cabaa487", + "usage": "input" + }, + { + "git_blob": "9e4d8fc6082171da5ec474905b798ff551fd5bbd", + "path": "research/rank7-t740-carrier-skips/SOURCES.json", + "sha256": "36a08c53fa64a0d3a5da50a4c60176fe57b420609bf820145def427c970b2070", + "usage": "input" + }, + { + "git_blob": "a4610190c1e1757a6ca8cd1ddb54e4851298db10", + "path": "research/rank7-t740-carrier-skips/TASK.json", + "sha256": "5495faebd634298d688c30bbf5a2dad8313753d5bfef12036852e2b3ca68c328", + "usage": "input" + }, + { + "git_blob": "cf1f910f295bd1021f093c5e640f4da0843bd0f6", + "path": "research/rank7-t740-carrier-skips/VENDOR.json", + "sha256": "57ba951de77ccea1731217ee19d88c987ba19859809af5f06e322ca05d4e03fe", + "usage": "input" + }, + { + "git_blob": "40e275b54d20c97d559174859094089cbf33e7af", + "path": "research/rank7-t740-carrier-skips/VERIFY.json", + "sha256": "da6914042474ec3375991ed5441e5c5e695e14cb94504341c4ddf85e28fd5bd6", + "usage": "input" + }, + { + "git_blob": "763b9771e2060897c33f201d9279bf2a34227ff0", + "path": "research/rank7-t740-carrier-skips/evidence/ADAPTER-DERIVATION.json", + "sha256": "3d95161373ca10d0d0a50033a33a1fdd2ee668d0c1a76e7624578d412a53edd9", + "usage": "input" + }, + { + "git_blob": "800a418fc4573827c8ffa81fb893d7c00a6061cf", + "path": "research/rank7-t740-carrier-skips/evidence/ADMISSION-RESULT.json", + "sha256": "620547340105d4355cd71e316183b70d6c7f381bef7da32cfe7761cbe2a450ae", + "usage": "input" + }, + { + "git_blob": "e90a03b0ff6150ba0a00c9c7d76e4199306e322c", + "path": "research/rank7-t740-carrier-skips/evidence/ADMISSION-STAGES.json", + "sha256": "59523b9c4f685db1920e5ff074cb943304b1c9b268ba07a97a2031c838faf849", + "usage": "input" + }, + { + "git_blob": "255a8b2de4e646aa342e3ca974d81e5629c53415", + "path": "research/rank7-t740-carrier-skips/evidence/ASYNC-AUDIT.json", + "sha256": "5150a14311d88b08c18d4c745772d010af61a477c6c12a41aa56693bb1fd2a1e", + "usage": "input" + }, + { + "git_blob": "7616fba960cf8b52f515f339d8dec38ea2d8cc4b", + "path": "research/rank7-t740-carrier-skips/evidence/COMPOSITION-RESULT.json", + "sha256": "fd636fa94779dd091a8c5ca7907906d33ee820ddcf6f6c0ac874a9b80ea3e776", + "usage": "input" + }, + { + "git_blob": "149cf531c60412d2825c9705c96bdc1b1f26c343", + "path": "research/rank7-t740-carrier-skips/evidence/DECISIONS.tsv", + "sha256": "270c229b5fc243546dd10ec478270a1d40cd7232da355aa4ee98e9bbee581be5", + "usage": "input" + }, + { + "git_blob": "067f955a217d8a54ea0afcce8bc46dd3ce60a94d", + "path": "research/rank7-t740-carrier-skips/evidence/DISCOVERY-INVOICE.json.gz", + "sha256": "98f1bf4a1f2c2447536ff66ac75cbe92f8e0f69143ff76117d18e2ef8fa84599", + "usage": "input" + }, + { + "git_blob": "969acafecea505af72d78aaa2f9169787b55bafc", + "path": "research/rank7-t740-carrier-skips/evidence/DISCOVERY-RESULT.json", + "sha256": "5c023597aacc4bc4cf2e62d796ea0adb899dda5fb1deb12f558a4c3dae27bb3b", + "usage": "input" + }, + { + "git_blob": "3b2f8894687405e1d3f16f1f4a6aefe65989cb69", + "path": "research/rank7-t740-carrier-skips/evidence/DISCOVERY-STAGES.json", + "sha256": "d495fde14c4e91d2bacbc763ac89dbc102094db3b4fa22806c77a77b0ad70b75", + "usage": "input" + }, + { + "git_blob": "a168f1b1e9aa88959e2d06be5df571c6b0db6e4b", + "path": "research/rank7-t740-carrier-skips/evidence/ENVIRONMENT.json", + "sha256": "f507fe197f9a2eb40e53b7e3b0479581ade59d6c95317d461ad4e26dc2e49cad", + "usage": "input" + }, + { + "git_blob": "5a3f9c43b0dc6862147453789d84a5c8f178d3b4", + "path": "research/rank7-t740-carrier-skips/evidence/FINITE.json", + "sha256": "ed63ec8457d7d003910a486078704eb03a38b6e8d171776cad4992522fe10937", + "usage": "input" + }, + { + "git_blob": "97c80437544842db3d2d80feb785ef59ddd39509", + "path": "research/rank7-t740-carrier-skips/evidence/GLOBAL-PREFIX.json", + "sha256": "2f6acd513f8e565e7390536d60d47a6cbb9742cd237082e2817cc9eec15c0eb5", + "usage": "input" + }, + { + "git_blob": "99ff4d49b69894ea4e0dd9d3203aabe705575f36", + "path": "research/rank7-t740-carrier-skips/evidence/INVOICE-PAYLOAD.json", + "sha256": "4faf5439f10a945b4e333d57913e57515d8c92e158cb490591a8deb447eb32e9", + "usage": "input" + }, + { + "git_blob": "f45ffdf06751c07651ae44c530aed9158e0050d6", + "path": "research/rank7-t740-carrier-skips/evidence/MATERIALIZED.json", + "sha256": "b6269af21561e4dd0827c9fb6ee4dbda1734857c12d1a16421c6e1bf76c38c5f", + "usage": "input" + }, + { + "git_blob": "6f3093b80e5b541f0b158c64939eabce5e69658a", + "path": "research/rank7-t740-carrier-skips/evidence/NATIVE-LOCAL-REPLAY-base.json", + "sha256": "178a58525831bdffb5757447a2253512de6cde3a58e5a926d362d0d2eeb35e15", + "usage": "input" + }, + { + "git_blob": "829b3c016398a3210544ffaf8bdcf069fc706818", + "path": "research/rank7-t740-carrier-skips/evidence/NATIVE-LOCAL-REPLAY-extra.json", + "sha256": "d29bf115dd47e6a4397bd9996d1666acdce43a83e354dfd7ea3890ed7c1863c4", + "usage": "input" + }, + { + "git_blob": "1221d4a6d1b7077e061ca115e6ba69f159c32f07", + "path": "research/rank7-t740-carrier-skips/evidence/NATIVE-RECEIPT.json", + "sha256": "ad648ae883f148b3edf3f795cdb320cf670efd0d777597a29dfaf1ea7f6393da", + "usage": "input" + }, + { + "git_blob": "c567e9b80f354372d93f0ee54825b1eee6950e66", + "path": "research/rank7-t740-carrier-skips/evidence/OUTER-B.json", + "sha256": "577a1d1dc8fd291c8b610bcd48ec408b7f538233cdcc9256ebe62fca2064496a", + "usage": "input" + }, + { + "git_blob": "5faee2a46e1c9101f90c4df2ecc8b7c9c592e5fe", + "path": "research/rank7-t740-carrier-skips/evidence/OUTER-CLAIM.json", + "sha256": "2fb2f1dd2c86abe53eb8513b006762c8be542902c99308e4b24642a2b087d3d8", + "usage": "input" + }, + { + "git_blob": "dbd034b3b92c2ae355bb2adec479667eab2bb7aa", + "path": "research/rank7-t740-carrier-skips/evidence/OUTER-INDEPENDENT.json", + "sha256": "f6b9201e8edc1837d4a73ba32f143d7486d769b7917e0f8ee77c918511a6a5e0", + "usage": "input" + }, + { + "git_blob": "7c47cd33cc8436adac160f04b1b3a4c3ab57a8f7", + "path": "research/rank7-t740-carrier-skips/evidence/OUTER-LEDGER.json", + "sha256": "d588da34a0f27b9d4314e91befea0dfff90c8d55006a00dc906b963f70718e46", + "usage": "input" + }, + { + "git_blob": "a9b259f4021d0fda9f7b74c88c7d936caf90e37c", + "path": "research/rank7-t740-carrier-skips/evidence/OVERLAP.json", + "sha256": "660cd777343d7078c6799acc0f8689523b694736d387c7cd0f97728364462cf6", + "usage": "input" + }, + { + "git_blob": "2baa1fbdb1d431bf06af9b3581b966b07fb78d63", + "path": "research/rank7-t740-carrier-skips/evidence/PREFLIGHT.json", + "sha256": "a927c6a4db213cb31c1c917c73d432d5931dfc9a34b5d3acfea04e1e5a1c7803", + "usage": "input" + }, + { + "git_blob": "4464ba5992003ff16b5a99346ddd92442929bdcd", + "path": "research/rank7-t740-carrier-skips/evidence/RECEIPT-CHECK.json", + "sha256": "6b5d5b030304e2f156a4aea52310a83711352718ec1665db02f36362dc55adfd", + "usage": "input" + }, + { + "git_blob": "6c23406066262ac9a22a569c697555c5270ee57c", + "path": "research/rank7-t740-carrier-skips/evidence/RECIPE.json", + "sha256": "d2a7db52b75c44d123e845aa9b1840e22fa633897eded0c3cf63966a9a4ffae4", + "usage": "input" + }, + { + "git_blob": "3ed59a3363c08d127906cf2990f141528ed85823", + "path": "research/rank7-t740-carrier-skips/evidence/RELEASE-RECEIPT.json", + "sha256": "0b6cc9b561cf1df89c31ded78dd6cea62dcfe3e1cf94bee8199913ba9898cb99", + "usage": "input" + }, + { + "git_blob": "be170646ea3c0d537f2de39df6b2e2190e2c7102", + "path": "research/rank7-t740-carrier-skips/evidence/STAGES.json", + "sha256": "3f509d7566aece03c1d5430992c5c31b5b0c4ae41f2f03982d2f239f2229e161", + "usage": "input" + }, + { + "git_blob": "84e17f12f8df747477e201afa4ac9d9686f6d50a", + "path": "research/rank7-t740-carrier-skips/evidence/VALIDATION.json", + "sha256": "437c279406f43bcf5c1a5bd46d5e0732dbc43ab40ea6962afa6de16d2f18afe9", + "usage": "input" + }, + { + "git_blob": "e2d86a6c3fb96ea5d8cc481401ad5757f88f7061", + "path": "research/rank7-t740-carrier-skips/evidence/VENDOR-CHECK.json", + "sha256": "13287014664f503c88db23fe97176bb32d2b1adc368d25b80ae697a2b724466b", + "usage": "input" + }, + { + "git_blob": "fba406c2504528941fc8d75f2a9eba1c22d45ca1", + "path": "research/rank7-t740-carrier-skips/evidence/logs/baseline.log.txt", + "sha256": "ff159ef8b51213ee06d088103f82e16e094c5b25fba7429999678259e8480262", + "usage": "input" + }, + { + "git_blob": "fb367e77afb3d9938fbed2ab1d3d2ae2750db301", + "path": "research/rank7-t740-carrier-skips/evidence/logs/complete-admission.log.txt", + "sha256": "16c7e28a72fb06ee6c5e5526e030918739e0f0aaa0a8f2fc5e04eae824a43c48", + "usage": "input" + }, + { + "git_blob": "621c292a9b74e435705d4f8d422a9d3df8d159e5", + "path": "research/rank7-t740-carrier-skips/evidence/logs/declared-edit-stage.log.txt", + "sha256": "e0d0595445e237ed99b78764aeb387fea1e7d4e1c5316fc78e49b2ebfc773de5", + "usage": "input" + }, + { + "git_blob": "fe82f1df84b87cd647b143c9f23ad05a682bf83f", + "path": "research/rank7-t740-carrier-skips/evidence/logs/derive-closed-adapters.log.txt", + "sha256": "b609bb3d24638aaa2470ed088549ee440e49534cc887df0ca2963387f751ebed", + "usage": "input" + }, + { + "git_blob": "6f2455c10a8081d3e7d0b78754920053bfc9204e", + "path": "research/rank7-t740-carrier-skips/evidence/logs/export-pr2833.log.txt", + "sha256": "9216cb2b782924e93460cc6f4b69d05ba53ff5028a14215c20c43ba65a5c1744", + "usage": "input" + }, + { + "git_blob": "2bed900376db47d928ffe64835940c728d3e4094", + "path": "research/rank7-t740-carrier-skips/evidence/logs/export-pr2894.log.txt", + "sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "usage": "input" + }, + { + "git_blob": "cfcc9dbb87a7b1049519a979629802cf97a2aaf9", + "path": "research/rank7-t740-carrier-skips/evidence/logs/finite-generation.log.txt", + "sha256": "0e3dc3db63566239a0ee69a552400e134fb2ff996c3b58109079c7013e5aa429", + "usage": "input" + }, + { + "git_blob": "257be58c74eb0f54ee80f34af65e64e9f201935a", + "path": "research/rank7-t740-carrier-skips/evidence/logs/four-kernel-stage.log.txt", + "sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "usage": "input" + }, + { + "git_blob": "820460ef57351ee8e921a122c460254594e0c05c", + "path": "research/rank7-t740-carrier-skips/evidence/logs/fresh-current-native.log.txt", + "sha256": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "usage": "input" + }, + { + "git_blob": "9308a84963a6bf0ebcf3e0343c2bc92655d8e3c0", + "path": "research/rank7-t740-carrier-skips/evidence/logs/fresh-retained-bootstrap.log.txt", + "sha256": "4a1625fdd9a947187583e67492c492f309e28669082f2e6f2aa97b5da345ea29", + "usage": "input" + }, + { + "git_blob": "9ca3a425215401648870f3f65397a683c028abfb", + "path": "research/rank7-t740-carrier-skips/evidence/logs/paired-extension-stage.log.txt", + "sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "usage": "input" + }, + { + "git_blob": "de80347a9094a0741e644d36c1f75487fa664424", + "path": "research/rank7-t740-carrier-skips/evidence/logs/parent-paired-stage.log.txt", + "sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "usage": "input" + }, + { + "git_blob": "4fa79b5e482d644cbe1d2c882dbc3296d367db9b", + "path": "research/rank7-t740-carrier-skips/evidence/logs/preload-stage.log.txt", + "sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "usage": "input" + }, + { + "git_blob": "d058b55c96bf06d7e9f888559ef27df5417f354d", + "path": "research/rank7-t740-carrier-skips/evidence/logs/rank7-overlay-stage.log.txt", + "sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "usage": "input" + }, + { + "git_blob": "f8573e3eb1975040e5facee3020f89758f226a9d", + "path": "research/rank7-t740-carrier-skips/evidence/logs/registered.log.txt", + "sha256": "38f8c7a1b9ffec1714c727745f50018d293318ba54529efdee0183d38733111a", + "usage": "input" + }, + { + "git_blob": "8924b585f02fc5d2de7589994daa212d6c776da6", + "path": "research/rank7-t740-carrier-skips/evidence/logs/release-verify.log.txt", + "sha256": "eed65b2764b3417205c43d7ea2f6806ef4f2922bfb8c9c3805ca53aea1c1e8b3", + "usage": "input" + }, + { + "git_blob": "fbfbb199ad9e24fd5586d200dec7689393a1d7a9", + "path": "research/rank7-t740-carrier-skips/evidence/logs/source-preflight.log.txt", + "sha256": "33398f425eb773647292f653df20b6bec51ab4a6ea56e9a3ee71a47978deef98", + "usage": "input" + }, + { + "git_blob": "441071c451f0ebea6abb1bfa80482559cd5031ba", + "path": "research/rank7-t740-carrier-skips/evidence/logs/tests-optimized.log.txt", + "sha256": "497b7b44efb66bc81c713ac1aabb4411b994911ecc547811767b03206a8b6d26", + "usage": "input" + }, + { + "git_blob": "2dc7caf1030addd67793a7ddb2e17eb935409246", + "path": "research/rank7-t740-carrier-skips/invoice_check.py", + "sha256": "aad22d2e0dadbbd80c9adb017d18f096bb66cc7c5974059eff2197f6146237b5", + "usage": "input" + }, + { + "git_blob": "9cfd0484b33af4fb5d21ae95c65849019cbf7124", + "path": "research/rank7-t740-carrier-skips/materialize.py", + "sha256": "46d26e13ba50d87710034b038b86eaf997e76424aa12e7d2408ef88dae7e17f6", + "usage": "input" + }, + { + "git_blob": "36718b41dedc5c6353c0d13897d4cd915ea8224d", + "path": "research/rank7-t740-carrier-skips/reproduce.py", + "sha256": "af3fbb942180e381145f293e2a2ab8052ce3514e2a6ad1d7d4caceadf34636ed", + "usage": "input" + }, + { + "git_blob": "e1d4e7582bedc204ca6da844568febf602af3cc5", + "path": "research/rank7-t740-carrier-skips/requirements-full.txt", + "sha256": "13f257631f46d3c774495c6b22351899a825afb226410856b2c549535022632f", + "usage": "input" + }, + { + "git_blob": "0e3184c8c539031ed70b20c15bb66f2b140552bf", + "path": "research/rank7-t740-carrier-skips/test_invoice.py", + "sha256": "8116a9e6312ae3bc4b6db12fc9f35c122a3787593bc4f1467ba912399719063a", + "usage": "input" + }, + { + "git_blob": "ce29755c2ce32ba610dca11ee872e85023747166", + "path": "research/rank7-t740-carrier-skips/test_verify.py", + "sha256": "194a0421b9e80e2e9c84149cafea5ade5a77508322d1e1a853e988cf3dfee940", + "usage": "input" + }, + { + "git_blob": "399bcc26f0684cced978e3a4c90f834551f62dd7", + "path": "research/rank7-t740-carrier-skips/vendor/PR3021-RESULT.json", + "sha256": "cdc4874dcb17714fbe10f003a4a4516b80a9ddccfc7199278a53baa13c5d3a04", + "usage": "input" + }, + { + "git_blob": "d8c6364feea0fc4476ef5fda47619a182030675e", + "path": "research/rank7-t740-carrier-skips/vendor/PR3030-INVOICE.json.gz", + "sha256": "d65530abcd7c8a8837d26b2a418293981b7b308c7f20c29e7aaa65e106299250", + "usage": "input" + }, + { + "git_blob": "1260c8d95f573a574e007038263adf883b5ecbd2", + "path": "research/rank7-t740-carrier-skips/vendor/pr3018/EXCHANGE.json", + "sha256": "8a103f643ad12d8074972f41e4359d9487eb8b96fc6849e1a178adb61b36578b", + "usage": "input" + }, + { + "git_blob": "6f73992ff764a3d527d4fd551057dc6fa254127e", + "path": "research/rank7-t740-carrier-skips/vendor/pr3021-FINITE.json", + "sha256": "f7f6aca1e2596d7049ff2bc69c523013324f568f86fd31b1f29899b96b2617eb", + "usage": "input" + }, + { + "git_blob": "f8f295f6cf377559ae59c6e40972b635b5ce2f21", + "path": "research/rank7-t740-carrier-skips/vendor/pr3021/reproduce.py", + "sha256": "8dffca928c1ad1a36423b18a33a3f591af0e46bb3482e0e1cf127ddb613ef11b", + "usage": "input" + }, + { + "git_blob": "84902a90d268579f4110cbb298375365d8121021", + "path": "research/rank7-t740-carrier-skips/vendor/pr3021/verify.py", + "sha256": "dac43246695dfc618ffc49866c1c2e1ba08bc7fd7d2deec2b6aa6b9c292d9cf3", + "usage": "input" + }, + { + "git_blob": "1b1a904ff05e848bfb2793597b9613cc997c3367", + "path": "research/rank7-t740-carrier-skips/vendor/pr3024/EXCHANGE.json", + "sha256": "18b3af92dab108945fa7033a2476a8521416b403415a31cdbbe2d1315bb1c827", + "usage": "input" + }, + { + "git_blob": "28f0995a69fbb003238f5ee8d1acf407bb1b37be", + "path": "research/rank7-t740-carrier-skips/vendor/pr3024/cap_proof.py", + "sha256": "7c5f362ed21dbbdbd6a0632aebef424213a37c47c86151a0520d097e8f4e321f", + "usage": "input" + }, + { + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "path": "research/rank7-t740-carrier-skips/vendor/pr3024/lift.py", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "usage": "input" + }, + { + "git_blob": "47a55a7f68efc1d5babec487d09a1f45f95c3221", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/CLAIM.json", + "sha256": "adb2efbaa7c16bf66aede2ac739e445e6fa974d5defbff8b70324f4f10632aa3", + "usage": "input" + }, + { + "git_blob": "85b68ae52e139e83a7ff2ef2870024d420881cb0", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/CREDITS.md", + "sha256": "8475f5e7c090e05196cfd6c2894516cbbedd5876f54193fea575d8064e23574e", + "usage": "input" + }, + { + "git_blob": "7018d721f594be3e22e291f44cfdd59e02a43485", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/MANIFEST.json", + "sha256": "da2b0fbe030ed5981ea105720042f5be8f56803c141e0be326776eb08e379406", + "usage": "input" + }, + { + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/NOTICE", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "usage": "input" + }, + { + "git_blob": "c0575e39034932eef6c66b1a7848e4d9771e9bf4", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/allocation/PROVIDERS.json", + "sha256": "04c9f2620178322010f7bafb30c669cad0be1426a905275d28a398398b596cd0", + "usage": "input" + }, + { + "git_blob": "c2042a37bdba0febb791d39bcb1f9f55de9fb14e", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/edits/EDITS.json", + "sha256": "ebffcc1e57e59439b9678ff8d9be518c457af22ce77235c2fdb46540ab9b9b79", + "usage": "input" + }, + { + "git_blob": "2ee02e318c98281a71445b954feccd55c153827c", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-base.json.gz", + "sha256": "7e98f6f2a6c9ce9e7e04b515bd8ce4a4a533ff05f01ea265be2a1a994695260e", + "usage": "input" + }, + { + "git_blob": "33ba5f34996a31edd197cb58eca575645575e529", + "path": "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-extra.json.gz", + "sha256": "1396410de482883416fc7f534062ab005b484056b035fdcfa3b5cc065536ba35", + "usage": "input" + }, + { + "git_blob": "3bd142311aa5e7134deb2aaf6a09fdc6347e6eaa", + "path": "research/rank7-t740-carrier-skips/verify.py", + "sha256": "4345698b1ae187f3708f9fa01313def62208f3165b799ee86cd9de5db7a9e5dc", + "usage": "input" + }, + { + "git_blob": "b63351c861dff0c285f7762e36e381786c81f201", + "path": "research/rank7-t740-carrier-skips/verify_release.py", + "sha256": "9b2ab4c773862d1fc9a62efd1d54505b86f3d23ee30bb354da924f0fd1deff18", + "usage": "input" + }, + { + "git_blob": "50b74b1d6d26fa11aa801d4207fbd9d067c568e8", + "path": "research/rank7-t740-carrier-skips/word_check.py", + "sha256": "f525647b903f9b8b2187f45f54cd7596dbec51e0024ed5fee80006adce65842b", + "usage": "input" + }, + { + "git_blob": "0d96586a00f03058d6dc1d7882ec8fbe6661ed00", + "path": "research/two-sided-helper-extraction/tools/audit_moment.py", + "sha256": "e7147ccb8c57aa32a2cb227234a6a200a0b9e735eb1a655fd79ab29a4d7c0a00", + "usage": "input" + }, + { + "git_blob": "dbc974a289a2060dc1f28bcd31414af7a2631d3c", + "path": "research/two-sided-helper-extraction/tools/admit_channel408.py", + "sha256": "a62c21eac4e0df502cbfb78c88b19a763fd351cde3c11c0588874f84db6992bf", + "usage": "input" + } + ], + "schema_version": 1 +} diff --git a/research/t740-six-skip-precision30/TASK.json b/research/t740-six-skip-precision30/TASK.json new file mode 100644 index 0000000000..0cf2c05d80 --- /dev/null +++ b/research/t740-six-skip-precision30/TASK.json @@ -0,0 +1,73 @@ +{ + "actual_scope": "Refine the exact outer point of the unchanged PR3054 T740 six-skip construction to a 30-digit endpoint and replay complete changed admission.", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review.", + "author": "dataisfire", + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "bottleneck_link": "Removes part of the 24-digit rounding slack while preserving every physical cost and inherited theorem hypothesis.", + "budget_minutes": 180, + "budget_note": "Extended to finish the authorized PR: the completed baseline, corrected selector and complete strict release required additional replay time.", + "evidence": "Both exact moment engines and the complete baseline and refined strict releases passed. Sealed evidence binds actual terminal receipts, admission logs and unchanged native sources; nomination checkpoint reuse is disclosed.", + "open_questions": [ + { + "blocked_by": "A complete changed-cost mechanism and its native/physical/outer release remain required.", + "first_step": "Name a changed scalar or centre interface outside the fixed-word frame and packing optima, and price it fully.", + "question": "Can a changed paid supplier profile improve kappa materially?", + "why_it_matters": "This refinement gains less than 1e-24 and leaves the construction unchanged." + } + ], + "original_card": { + "acceptance_gate": "Check live PR overlap first, price both suppliers and distinguish a search best from an optimum. Report the word's packing cap from ceiling.ceiling() and the fraction of it realized; label packing gains as such.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "existing_checks": [ + { + "evidence": "docs/research/community-efficient1000-review.md", + "remaining": "A changed word or model requires new pricing; a local packing search must name uncovered scope.", + "scope": "Packing-independent ceiling for the selected paid profile under the one-unpaid-coordinate coverage and halving guard.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "status": "reviewed" + } + ], + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Locate the selected packing source in the review and check live PRs for the same residual problem.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "selected-packing", + "methods": [ + "Search a named unclaimed canonical candidate domain with a reproducible partition.", + "Prove a stronger scoped relaxation or exact optimum for one named residual subproblem." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ], + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ] + }, + "outcome": "completed", + "priority_revision": 6, + "schema_version": 1, + "scope_change_reason": "Explicit user asks for a strictly higher fully verified kappa than every existing claim. This is a tiny arithmetic refinement, not new independent verification coverage or a changed supplier.", + "scope_status": "changed", + "stop_rule": "No publication until completed unmodified baseline and complete refined native-cache-bound admission, with a fresh competing-claim check.", + "task_id": "selected-packing" +} diff --git a/research/t740-six-skip-precision30/VERIFY.json b/research/t740-six-skip-precision30/VERIFY.json new file mode 100644 index 0000000000..063707acdb --- /dev/null +++ b/research/t740-six-skip-precision30/VERIFY.json @@ -0,0 +1,133 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Exact gain with both credited moment engines, higher-point and unpaid-child rejection, mandatory completed-release evidence and every original outer margin/control. Does not rerun native chains.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "-O", + "-m", + "unittest", + "discover", + "-s", + "{package}", + "-p", + "test_*.py", + "-v" + ], + "checks": "Actual inherited ledger mutants reject wrong points, zero margins and missing controls; strict completion flags reject unfinished or malformed releases under optimized Python.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/complex-local-word-ceiling/ceiling.py", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/FILL.json.gz", + "research/rank7-joint-endframes/allocation/ORDER.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/certificates/RELAX-CAP.json", + "research/rank7-joint-endframes/data/WORD-base.json.gz", + "research/rank7-joint-endframes/data/WORD-extra.json.gz", + "research/rank7-joint-endframes/tools/root.py", + "research/rank7-t740-carrier-skips/.gitattributes", + "research/rank7-t740-carrier-skips/ADAPTED.json", + "research/rank7-t740-carrier-skips/ENGINEERING.md", + "research/rank7-t740-carrier-skips/GIT-SOURCES.json", + "research/rank7-t740-carrier-skips/PINS.json", + "research/rank7-t740-carrier-skips/README.md", + "research/rank7-t740-carrier-skips/SOURCES.json", + "research/rank7-t740-carrier-skips/TASK.json", + "research/rank7-t740-carrier-skips/VENDOR.json", + "research/rank7-t740-carrier-skips/VERIFY.json", + "research/rank7-t740-carrier-skips/evidence/ADAPTER-DERIVATION.json", + "research/rank7-t740-carrier-skips/evidence/ADMISSION-RESULT.json", + "research/rank7-t740-carrier-skips/evidence/ADMISSION-STAGES.json", + "research/rank7-t740-carrier-skips/evidence/ASYNC-AUDIT.json", + "research/rank7-t740-carrier-skips/evidence/COMPOSITION-RESULT.json", + "research/rank7-t740-carrier-skips/evidence/DECISIONS.tsv", + "research/rank7-t740-carrier-skips/evidence/DISCOVERY-INVOICE.json.gz", + "research/rank7-t740-carrier-skips/evidence/DISCOVERY-RESULT.json", + "research/rank7-t740-carrier-skips/evidence/DISCOVERY-STAGES.json", + "research/rank7-t740-carrier-skips/evidence/ENVIRONMENT.json", + "research/rank7-t740-carrier-skips/evidence/FINITE.json", + "research/rank7-t740-carrier-skips/evidence/GLOBAL-PREFIX.json", + "research/rank7-t740-carrier-skips/evidence/INVOICE-PAYLOAD.json", + "research/rank7-t740-carrier-skips/evidence/MATERIALIZED.json", + "research/rank7-t740-carrier-skips/evidence/NATIVE-LOCAL-REPLAY-base.json", + "research/rank7-t740-carrier-skips/evidence/NATIVE-LOCAL-REPLAY-extra.json", + "research/rank7-t740-carrier-skips/evidence/NATIVE-RECEIPT.json", + "research/rank7-t740-carrier-skips/evidence/OUTER-B.json", + "research/rank7-t740-carrier-skips/evidence/OUTER-CLAIM.json", + "research/rank7-t740-carrier-skips/evidence/OUTER-INDEPENDENT.json", + "research/rank7-t740-carrier-skips/evidence/OUTER-LEDGER.json", + "research/rank7-t740-carrier-skips/evidence/OVERLAP.json", + "research/rank7-t740-carrier-skips/evidence/PREFLIGHT.json", + "research/rank7-t740-carrier-skips/evidence/RECEIPT-CHECK.json", + "research/rank7-t740-carrier-skips/evidence/RECIPE.json", + "research/rank7-t740-carrier-skips/evidence/RELEASE-RECEIPT.json", + "research/rank7-t740-carrier-skips/evidence/STAGES.json", + "research/rank7-t740-carrier-skips/evidence/VALIDATION.json", + "research/rank7-t740-carrier-skips/evidence/VENDOR-CHECK.json", + "research/rank7-t740-carrier-skips/evidence/logs/baseline.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/complete-admission.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/declared-edit-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/derive-closed-adapters.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/export-pr2833.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/export-pr2894.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/finite-generation.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/four-kernel-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/fresh-current-native.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/fresh-retained-bootstrap.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/paired-extension-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/parent-paired-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/preload-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/rank7-overlay-stage.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/registered.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/release-verify.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/source-preflight.log.txt", + "research/rank7-t740-carrier-skips/evidence/logs/tests-optimized.log.txt", + "research/rank7-t740-carrier-skips/invoice_check.py", + "research/rank7-t740-carrier-skips/materialize.py", + "research/rank7-t740-carrier-skips/reproduce.py", + "research/rank7-t740-carrier-skips/requirements-full.txt", + "research/rank7-t740-carrier-skips/test_invoice.py", + "research/rank7-t740-carrier-skips/test_verify.py", + "research/rank7-t740-carrier-skips/vendor/PR3021-RESULT.json", + "research/rank7-t740-carrier-skips/vendor/PR3030-INVOICE.json.gz", + "research/rank7-t740-carrier-skips/vendor/pr3018/EXCHANGE.json", + "research/rank7-t740-carrier-skips/vendor/pr3021-FINITE.json", + "research/rank7-t740-carrier-skips/vendor/pr3021/reproduce.py", + "research/rank7-t740-carrier-skips/vendor/pr3021/verify.py", + "research/rank7-t740-carrier-skips/vendor/pr3024/EXCHANGE.json", + "research/rank7-t740-carrier-skips/vendor/pr3024/cap_proof.py", + "research/rank7-t740-carrier-skips/vendor/pr3024/lift.py", + "research/rank7-t740-carrier-skips/vendor/pr3042/CLAIM.json", + "research/rank7-t740-carrier-skips/vendor/pr3042/CREDITS.md", + "research/rank7-t740-carrier-skips/vendor/pr3042/MANIFEST.json", + "research/rank7-t740-carrier-skips/vendor/pr3042/NOTICE", + "research/rank7-t740-carrier-skips/vendor/pr3042/allocation/PROVIDERS.json", + "research/rank7-t740-carrier-skips/vendor/pr3042/edits/EDITS.json", + "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-base.json.gz", + "research/rank7-t740-carrier-skips/vendor/pr3042/edits/FINAL-WORD-extra.json.gz", + "research/rank7-t740-carrier-skips/verify.py", + "research/rank7-t740-carrier-skips/verify_release.py", + "research/rank7-t740-carrier-skips/word_check.py", + "research/two-sided-helper-extraction/tools/admit_channel408.py", + "research/two-sided-helper-extraction/tools/audit_moment.py" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/t740-six-skip-precision30/baseline.py b/research/t740-six-skip-precision30/baseline.py new file mode 100644 index 0000000000..a9eca50ec1 --- /dev/null +++ b/research/t740-six-skip-precision30/baseline.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Run the unchanged predecessor recipe with a larger outer wall-time allowance. + +Only run_stage's resource timeout changes from 1,800 to at least 7,200 seconds. +Commands, domains, scientific predicates, log binding and final release checks +are the original PR3054 implementation. Substantial OpenAI Codex assistance. +""" + +import argparse +import sys + +import verify as v + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--repo", type=v.Path, required=True) + parser.add_argument("--work", type=v.Path, required=True) + a = parser.parse_args() + v.need( + not a.work.resolve().is_relative_to(v.P), + "baseline logs and cache must stay outside the published package", + ) + v.authenticate() + parent = v.ROOT / "research/rank7-t740-carrier-skips" + sys.path.insert(0, str(parent)) + source = v.load(parent / "reproduce.py", "credited_baseline_budget") + original = source.run_stage + + def run_stage(name, command, work, env, stages, timeout): + allowance = max(timeout, 7200) if name == "complete-admission" else timeout + return original(name, command, work, env, stages, allowance) + + source.run_stage = run_stage + result = source.execute(a.repo.resolve(), a.work.resolve(), False) + source.save(a.work.resolve() / "RESULT.json", result) + v.need( + result["status"] == "PASS_T740_SIX_SKIP_COMPLETE_RELEASE", + "complete original baseline", + ) + print(result["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/t740-six-skip-precision30/checkpoint.py b/research/t740-six-skip-precision30/checkpoint.py new file mode 100644 index 0000000000..eeb84c30d9 --- /dev/null +++ b/research/t740-six-skip-precision30/checkpoint.py @@ -0,0 +1,312 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Resume nomination after the diagnosed coarse-selector failure. + +Only completed nomination geometry is reused. The final original strict +supplier/outer release runs in full. Exact authenticated producer statements +generate all receipts; no success receipt is hand-written here. +Substantial OpenAI Codex assistance; retained producers keep their credit. +""" + +import argparse +import ast +import contextlib +import os +import shutil +import sys +import textwrap +import time + +import verify as v + + +def execute(nodes, namespace, filename): + tree = ast.fix_missing_locations(ast.Module(body=nodes, type_ignores=[])) + exec(compile(tree, str(filename), "exec"), namespace) # authenticated source only + + +def called(node, name): + return ( + isinstance(node, ast.Expr) + and isinstance(node.value, ast.Call) + and isinstance(node.value.func, ast.Name) + and node.value.func.id == name + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--baseline-work", type=v.Path, required=True) + parser.add_argument("--work", type=v.Path, required=True) + a = parser.parse_args() + baseline, work = a.baseline_work.resolve(), a.work.resolve() + candidate = work / "candidate" + v.need(os.name == "posix" and not sys.flags.optimize, "POSIX, assertions required") + v.need(not work.is_relative_to(v.P), "external checkpoint required") + v.authenticate() + parent = v.ROOT / "research/rank7-t740-carrier-skips" + sys.path.insert(0, str(parent)) + original = v.load(parent / "reproduce.py", "checkpoint_complete_baseline") + r = v.read(baseline / "RESULT.json") + stages = v.read(baseline / "STAGES.json") + for stage in stages: + v.need( + stage["exit_code"] == 0 + and v.sha(baseline / (stage["stage"] + ".log")) == stage["log_sha256"], + "complete baseline stage/log", + ) + v.need( + original.check_release(baseline, baseline / "pr3042", r["fill_sha256"], stages) + == r, + "mandatory full baseline, not discovery", + ) + adapter = work / "admit_precision30.py" + old_body = adapter.read_text() + edits = v.read(v.P / "PRECISION-EDITS.json") + v.need( + len(edits) == 6 and old_body.count(edits[-1]["old"]) == 1, + "only diagnosed selector correction", + ) + new_body = old_body.replace(edits[-1]["old"], edits[-1]["new"]) + reference_hash, candidate_hash = v.expected_adapter_hashes() + v.need( + v.hashlib.sha256(new_body.encode()).hexdigest() == candidate_hash, + "exact authenticated corrected producer", + ) + saved = work / "failed-coarse-selector" + v.need(not saved.exists(), "preserve each failed attempt once") + saved.mkdir() + for source in ( + adapter, + work / "DERIVATION.json", + work / "complete-admission.log", + candidate / "RESULT.json", + candidate / "STAGES.json", + candidate / "RUNTIME-PATCHES.json", + ): + shutil.copyfile(source, saved / (source.parent.name + "-" + source.name)) + prepared = v.read(candidate / "RESULT.json") + v.need( + prepared["status"] == "PREPARED_REPLICA_SAME_WORD_DERIVATIVE_NOT_ADMITTED", + "prepared failed nomination, never an admitted receipt", + ) + old_stages = v.read(candidate / "STAGES.json") + v.need( + [s["name"] for s in old_stages] + == ["owners", "parent-lift", "rebind", "discovery"], + "exact failed checkpoint stage inventory", + ) + for stage in old_stages[:3]: + v.need( + stage["exit_code"] == 0 + and v.sha(candidate / (stage["name"] + ".log")) == stage["log_sha256"] + and v.sha(v.Path(stage["command"][2])) == stage["script_sha256"], + "actual completed preparation", + ) + adapter.write_bytes(new_body.encode()) + (work / "DERIVATION.json").write_bytes( + ( + v.json.dumps( + dict( + reference_sha256=reference_hash, + candidate_sha256=candidate_hash, + replacements=edits, + ), + indent=2, + sort_keys=True, + ) + + "\n" + ).encode() + ) + module = v.load(adapter, "authenticated_corrected_admission") + body = next( + n + for n in ast.parse(new_body).body + if isinstance(n, ast.FunctionDef) and n.name == "main" + ).body + command = v.expected_command("complete-admission", baseline, sys.executable) + command[command.index("--work") + 1] = str(candidate) + sys.argv = [str(adapter), *command[3:]] + ns = module.__dict__ + prefix = [] + for node in body: + if ( + isinstance(node, ast.Expr) + and isinstance(node.value, ast.Call) + and isinstance(node.value.func, ast.Attribute) + and isinstance(node.value.func.value, ast.Name) + and node.value.func.value.id == "work" + and node.value.func.attr == "mkdir" + ): + break + if ( + called(node, "need") + and len(node.value.args) > 1 + and isinstance(node.value.args[1], ast.Constant) + and node.value.args[1].value == "fresh external work required" + ): + continue # replaced by the authenticated prepared-checkpoint checks above + prefix.append(node) + execute(prefix, ns, adapter) + v.need( + ns["external_hashes"] == prepared["external_input_sha256"], + "unchanged literal inputs", + ) + env = dict( + os.environ, + PYTHONDONTWRITEBYTECODE="1", + PYTHONINTMAXSTRDIGITS="0", + OPENBLAS_NUM_THREADS="1", + OMP_NUM_THREADS="1", + ) + for key in ( + "PYTHONOPTIMIZE", + "PYTHONPATH", + "WITNESS_SPEC", + "WITNESS_RECORD", + "WITNESS_DISCOVER", + ): + env.pop(key, None) + runtime = candidate / "layout/packing74" + ns.update( + package=candidate / "package", + runtime=runtime, + data=runtime / "candidate", + result=prepared, + patches=prepared["patches"], + stages=old_stages[:3], + env=env, + ) + execute( + [ + next(n for n in body if isinstance(n, ast.FunctionDef) and n.name == name) + for name in ("patch", "run") + ], + ns, + adapter, + ) + insertion = ast.parse(textwrap.dedent(edits[-1]["new"])).body[0] + execute([insertion], ns, adapter) + ns["write"](candidate / "RUNTIME-PATCHES.json", ns["patches"]) + shutil.copyfile(ns["package"] / "code/assemble.py", runtime / "code/assemble.py") + replay_path = runtime / "replay.py" + expected_replay = (ns["source"] / "replay.py").read_text() + for node in body: + if ( + called(node, "patch") + and isinstance(node.value.args[0], ast.Constant) + and node.value.args[0].value == "replay.py" + ): + pairs = eval( + compile(ast.Expression(node.value.args[1]), str(adapter), "eval"), ns + ) + for before, after in pairs: + v.need( + expected_replay.count(before) == 1, "exact replay producer preimage" + ) + expected_replay = expected_replay.replace(before, after) + v.need( + replay_path.read_bytes() == expected_replay.encode(), + "source-authenticated replay continuation", + ) + replay = ast.parse(replay_path.read_bytes()).body + rn = dict(__file__=str(replay_path), __name__="authenticated_checkpoint_discovery") + initial = [] + for node in replay: + if isinstance(node, ast.Assign) and any( + isinstance(t, ast.Name) and t.id == "ap" for t in node.targets + ): + break + initial.append(node) + execute(initial, rn, replay_path) + discovery = candidate / "discovery" + ds = v.read(discovery / "STAGES.json") + v.need( + [s["name"] for s in ds] == ["bind", "emit", "audit", "invoice", "assembly"], + "exact failed discovery", + ) + for stage in ds[:4]: + v.need( + stage["exit_code"] == 0 + and v.sha(discovery / (stage["name"] + ".log")) == stage["log_sha256"], + "actual successful nomination geometry; not a skipped strict release", + ) + for filename in ("STAGES.json", "assembly.log", "WITNESS-RECORD.jsonl"): + shutil.copyfile(discovery / filename, saved / ("discovery-" + filename)) + up = rn["ROOT"] / "research/complex-k492-owner-repair/vendor/multicold" + denv = dict( + env, + PYTHONUTF8="1", + MULTICOLD_SOURCE=str(up), + GAIN_PR564_SOURCE=str(up), + WITNESS_SPEC=str(discovery / "runtime/data/SPEC.json"), + WITNESS_DISCOVER="1", + WITNESS_RECORD=str(discovery / "WITNESS-RECORD.jsonl"), + ) + rn.update( + a=argparse.Namespace(discover=True), + data=ns["data"], + work=discovery, + local=ns["natives"]["base"] / "local", + code=runtime / "code", + upstream=up, + spec=discovery / "runtime/data/SPEC.json", + env=denv, + stages=ds[:4], + g=discovery / "global", + ) + execute( + [next(n for n in replay if isinstance(n, ast.FunctionDef) and n.name == "run")], + rn, + replay_path, + ) + start = next( + i + for i, n in enumerate(replay) + if called(n, "run") + and isinstance(n.value.args[0], ast.Constant) + and n.value.args[0].value == "assembly" + ) + started = time.monotonic() + with ( + (candidate / "discovery-checkpoint.log").open("w") as transcript, + contextlib.redirect_stdout(transcript), + ): + execute(replay[start:], rn, replay_path) + resume_record = dict( + name="discovery-checkpoint", + exit_code=0, + seconds=time.monotonic() - started, + script_sha256=v.sha(v.Path(__file__)), + command=[sys.executable, "-B", str(v.Path(__file__))], + scope="Nomination geometry prefix reused; corrected assembly/freeze/independent executed. Final strict release is fresh.", + ) + resume_record["log_sha256"] = v.sha(candidate / "discovery-checkpoint.log") + ns["stages"].append(resume_record) + ns["result"]["checkpoint_scope"] = resume_record["scope"] + tail = next( + i + for i, n in enumerate(body) + if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "supplier" for t in n.targets) + ) + execute( + body[tail:], ns, adapter + ) # includes the original COMPLETE strict supplier and outer release + outer_path = v.P / "reproduce.py" + outer = ast.parse(outer_path.read_bytes()).body + finish = next( + i + for i, n in enumerate(outer) + if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "a" for t in n.targets) + and isinstance(n.value, ast.Call) + and isinstance(n.value.func, ast.Name) + and n.value.func.id == "read" + ) + ns.update(WORK=work, BASELINE=baseline, nom=v.calculate(), r=r, save=ns["write"]) + execute(outer[finish:], ns, outer_path) + + +if __name__ == "__main__": + main() diff --git a/research/t740-six-skip-precision30/evidence/DERIVATION.json b/research/t740-six-skip-precision30/evidence/DERIVATION.json new file mode 100644 index 0000000000..206ae15f67 --- /dev/null +++ b/research/t740-six-skip-precision30/evidence/DERIVATION.json @@ -0,0 +1,30 @@ +{ + "candidate_sha256": "5bbe0e95ad714e06e9256f7c456e0c043ebdb67c14a0b570409cf2f7fd46bc6b", + "reference_sha256": "1893fa959063f48b523ee9d1974aaaa487f80f19b8592c7210969e1d4419723e", + "replacements": [ + { + "new": "PRECISION = dict(endpoint_digits=30, grid_digits=24, margin_digits=34, bootstrap_steps=12)", + "old": "PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12)" + }, + { + "new": "dict(b=str(C-Q(1,10**110)), b_above_endpoint=str(C+Q(1,10**30)),", + "old": "dict(b=str(C-Q(1,10**104)), b_above_endpoint=str(C+Q(1,10**24))," + }, + { + "new": "kappa == C-Q(1,10**76)-Q(1,10**52)", + "old": "kappa == C-Q(1,10**70)-Q(1,10**46)" + }, + { + "new": "Endpoint precision30;", + "old": "Endpoint precision24;" + }, + { + "new": "kappa=C-10^-76-10^-52 exactly; same fixed-grid-maximum proof at precision30.", + "old": "kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24." + }, + { + "new": " patch('code/assemble.py', [(\" if DISCOVER:b=Q(M.certify(H,73,owner['live'],False)['lower']);conservative_b=Q(M.certify(H,73,owner['live'],True)['lower'])\", \" def fine_endpoint(bad):\\n digits=SPEC['outer_refinement']['endpoint_digits']\\n seed=Q(M.certify(H,73,owner['live'],bad)['lower'])\\n if digits<=24:return seed\\n grid=10**digits;left=int(seed*grid);right=left+10**(digits-24)\\n while right-left>1:\\n mid=(left+right)//2\\n lo,hi=FC.moment('fine_mercator',H,73,owner['live'],Q(mid,grid),bad)\\n if hi<1:left=mid\\n elif lo>1:right=mid\\n else:raise ArithmeticError('fine root enclosure exhausted; no endpoint accepted')\\n return Q(left,grid)\\n if DISCOVER:b=fine_endpoint(False);conservative_b=fine_endpoint(True)\")])\n spec['outer_refinement'] = PRECISION", + "old": " spec['outer_refinement'] = PRECISION" + } + ] +} diff --git a/research/t740-six-skip-precision30/evidence/OUTER-LEDGER.json b/research/t740-six-skip-precision30/evidence/OUTER-LEDGER.json new file mode 100644 index 0000000000..a650cbc1cf --- /dev/null +++ b/research/t740-six-skip-precision30/evidence/OUTER-LEDGER.json @@ -0,0 +1,575 @@ +{ + "status": "PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC", + "scope": "Conditional fine-prime padding composition. Fresh native admission is required by verify.py. The cited prime theorem, written gauge-free theorem and inherited all-size interfaces are not proved by this arithmetic. No independent human review is claimed.", + "geometry_changes": { + "theta_power": { + "rational": "2", + "decimal": "2" + }, + "halo_power": 48, + "core_power": 128, + "matrix_exponent": { + "rational": "45/16", + "decimal": "2.8125" + } + }, + "halo_umbrella": { + "umbrella_power": 10, + "theta_power": { + "rational": "2", + "decimal": "2" + }, + "exponent_budget": { + "rational": "13/2", + "decimal": "6.5" + }, + "margin": { + "rational": "7/2", + "decimal": "3.5" + }, + "fails_from_theta_power": { + "rational": "15/4", + "decimal": "3.75" + } + }, + "complex_lower_short": { + "rational": "172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999" + }, + "complex_lower_pinned": { + "rational": "1729737950064278551242895823/1000000000000000000000000000000", + "decimal": "0.001729737950064278551242895823" + }, + "native_moment": [ + { + "rational": "460688772561223309599799143185976108003539889470795328216968732914663907249925886700351413379492812099998552384728491487721539688842015448439320473057397546195029713/460688772561223309599799143187044542348256984914116263229517370635452168260760357920669766257038423772151901248872539660616526444082616288154471954520592778765795328", + "decimal": "0.99999999999999999999999999999768078926956027415071408678184235206373537637310804712172435124351291541411204466099944875813859648511958250016998233489690410927106005370311810844286094195784077758925668038857870837587621740937653576" + }, + { + "rational": "460688772561223309599799143185976108003539889470795328216968732914663907249925886700351413379492812099998552384728491487721539688842015448439320473057397546195029823/460688772561223309599799143187044542348256984914116263229517370635452168260760357920669766257038423772151901248872539660616526444082616288154471954520592778765795328", + "decimal": "0.99999999999999999999999999999768078926956027415071408678184235206373537637310804712172435124351291541411204466099944875813859648511958250016998233489690410927106029247603065078516873365557082618457959091367808448901809552945869060" + } + ], + "profile": { + "1": 16376940, + "2": 4741920, + "3": 1594737, + "4": 719280, + "5": 137085, + "8": 53280, + "48": 281903 + }, + "m": 73, + "W": 663040, + "online_final_kappa": { + "rational": "863375561558154078849/500000000000000000000000", + "decimal": "0.001726751123116308157698" + }, + "rows": { + "struct_boundary_radix_union": { + "kind": "struct_boundary_radix_union", + "kappa": { + "rational": "17297379500642785512428958229999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017297379500642785512428958229999999999999999999998999999999999999999999999" + }, + "epsilon": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "xi": { + "rational": "185954250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999995898454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.9079797379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999799729201035271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "beta": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "q": { + "rational": "86486897503213927562144791149999999999999999999999999999999999999999999999999999999999999999999999999999999/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999998" + }, + "a": { + "rational": "345947590012855710248579164599999999999999999999999999999999999999999999999999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001729737950064278551242895822999999999999999999999999999999999999999999999999999999999999999999999999999999985" + }, + "r0": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "zeta": { + "rational": "1/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-112" + }, + "slack": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "margins": { + "main_transform": { + "rational": "354250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999995900454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017297379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999799826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "global_coordinate_router": { + "rational": "345947590012855710248579164599999999999999999999999999999999999999999999999999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001729737950064278551242895822999999999999999999999999999999999999999999999999999999999999999999999999999999985" + }, + "fused_gaussian": { + "rational": "354250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999997943362111607104686909856190688550000000000000000000000000000000000000000000000000000000000000000000000000000123/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017297379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999899578228105815658540520321810964355468750000000000000000000000000000000000000000000000000000000000000000000006005859375" + }, + "group_bit_router": { + "rational": "1417001328692656989178180258201599999999999999999999999999999999999999999999999999999999999999999999999999995869448446428418747639424762754200000000000000000000000000000000000000000000000000000000000000000000000000000369/819200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001729737950064278551242895822999999999999999999999999999999999999999999999999999999999999999999999999999999994957822810581565854052032181096435546875000000000000000000000000000000000000000000000000000000000000000000000450439453125" + }, + "group_scans": { + "rational": "2047999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "boundary_algebraic_matrix": { + "rational": "354250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999997948454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017297379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999899826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "sparse_union_movement": { + "rational": "83554250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999997948454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4079797379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999899826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "polynomial_products": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "microbox_face_corrections": { + "rational": "78848000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "77.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400390625" + } + }, + "strict_checks": { + "actual_bit_above_effective": { + "rational": "737817905113136701220835400000000000000000000000000000000000000000000000000000000000000000000000000000003/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000003689089525565683506104177000000000000000000000000000000000000000000000000000000000000000000000000000000015" + }, + "complex_above_effective": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-111" + }, + "q_positive": { + "rational": "86486897503213927562144791149999999999999999999999999999999999999999999999999999999999999999999999999999999/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999998" + }, + "complex_endpoint": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "q_below_effective": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-111" + }, + "stop_positive": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-116" + }, + "stop_below_one": { + "rational": "99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" + }, + "leaf_saving_above_effective": { + "rational": "49999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "4.9999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001E-111" + }, + "q_below_internal": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-111" + }, + "q_below_leaf": { + "rational": "99999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.9999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001E-111" + }, + "lambda_above_tau": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-111" + }, + "lambda_above_sigma": { + "rational": "3/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "7.5E-111" + }, + "lambda_above_internal": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-111" + }, + "lambda_prime_above_lambda": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-111" + }, + "lambda_prime_above_leaf": { + "rational": "99999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.9999999827026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001E-111" + }, + "epsilon_positive": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "epsilon_below_one": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-110" + }, + "cap_above_band": { + "rational": "83554250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999995898454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4079797379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999799729201035271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "cap_below_cell": { + "rational": "18845749667826835752705454935449600000000000000000000000000000000000000000000000000000000000000000000000000002051545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0920202620499357214487571041770000000000000000000000000000000000000000000000000000000000000000000000000000000100173142714728113819826559396345214843749999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "group_positive": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "group_below_dimension": { + "rational": "41/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.001953125E-110" + }, + "support_router_span": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-110" + }, + "group_gauge_power_slack": { + "rational": "18845749667826835752705454935449600000000000000000000000000000000000000000000000000000000000000000000000000006152545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.184040524099871442897514208354000000000000000000000000000000000000000000000000000000000000000000000000000000060083456667945622763965311879269042968749999999999999999999999999999999999999999999999999999999999999999999999599609375" + }, + "actual_logarithmic_group_guard": { + "rational": "18845749667826835752705454935449600000000000000000000000000000000000000000000000000000000000000000000000000007176545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.184040524099871442897514208354000000000000000000000000000000000000000000000000000000000000000000000000000000070083456667945622763965311879269042968749999999999999999999999999999999999999999999999999999999999999999999999599609375" + }, + "global_gamma_power_slack": { + "rational": "1/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.765625E-114" + }, + "actual_logarithmic_gamma_guard": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-110" + }, + "alpha_logarithm_absorption": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "group_key_fits_record": { + "rational": "41/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.001953125E-110" + }, + "membership_arithmetic_fits_record": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-110" + }, + "microbox_halo_volume": { + "rational": "323584000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "79.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030029296875" + }, + "positive_layout_slack": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "short_record_fallback": { + "rational": "102222874833913417876352727467724800000000000000000000000000000000000000000000000000000000000000000000000000000511/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.998270262049935721448757104177000000000000000000000000000000000000000000000000000000000000000000000000000000004990234375" + }, + "improvement_over_online_final": { + "rational": "29868269479703935448958229999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000029868269479703935448958229999999999999999999998999999999999999999999999" + }, + "improvement_over_previous_local_final": { + "rational": "563778446585005512428958229999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000563778446585005512428958229999999999999999999998999999999999999999999999" + }, + "complex_below_one_over_32": { + "rational": "2952026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.02952026204993572144875710417700000000000000000000000000000000000000000000000000000000000000000000000000000001" + }, + "strassen_integer_power_gap": { + "rational": "1951441519231", + "decimal": "1951441519231" + }, + "theta_positive_polynomial_power": { + "rational": "2", + "decimal": "2" + }, + "cap_below_phase_cell_power": { + "rational": "223645749667826835752705454935449600000000000000000000000000000000000000000000000000000000000000000000000000004101545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0920202620499357214487571041770000000000000000000000000000000000000000000000000000000000000000000000000000000200270798964728113819826559396345214843749999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "halo_covers_generic_inverse_radius": { + "rational": "5", + "decimal": "5" + }, + "union_tag_work_per_visit_fits_record": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-110" + }, + "union_header_fits_record": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-110" + }, + "source_axis_superpolynomial": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-110" + }, + "improvement_over_pr1786": { + "rational": "2499158095711482123117397824999999999999999999995000000000009999999/50000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00004998316191422964246234795649999999999999999999990000000000019999998" + }, + "improvement_over_pr1828": { + "rational": "99965987877468059814449658158594846003377122994639409079344959674399999800000000000000000004006719019826502178085342683975683/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000499829939387340299072248290792974230016885614973197045396724798371999999000000000000000000020033595099132510890426713419878415" + }, + "improvement_over_pr1839": { + "rational": "249914969693670149536124145396487115008442807486598522698362399185677258198371805868475000000001001679754956625544521335670993920703/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000499829939387340299072248290792974230016885614973197045396724798371354516396743611736950000000002003359509913251089042671341987841406" + }, + "improvement_over_pr1875": { + "rational": "249914969693670149536124145396487115008442807486598522698362399185677258198371805868471719335776838627743415457068895139647759399172939286143496816535216421325187363046885361425772909502231218314437622205930116079297234806627210590217190600996553729143901162562581526621534715086055386213403722175000000001001679754956625544521335670993920703/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000049982993938734029907224829079297423001688561497319704539672479837135451639674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325442118" + }, + "improvement_over_pr1876": { + "rational": "24991496969367014953612414539648711500844280748659852269836239918567725819837180586847171933577683862774341545706889513964775939917293928614349681653521642132518736304688536142577290950223121831443762220593011607929723480662721059021719060099655372914390116256258152662153471508605538621340372217196657216794137380775174500330086462142358142864921147118845386980694114022172311249292673931726844600000000000000000001001679754956625544521335670993920702577/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000049982993938734029907224829079297423001688561497319704539672479837135451639674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325442118" + }, + "improvement_over_pr1897": { + "rational": "49982993938734029907224829079297423001688561497319704539672479837135451639674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325442118043438120199310745828780232512516305324306943017211077242680744434393314433588274761550349000660172924284716285729842294237690773961388228044344622498585347863453689118814253082419197486359454032147189198319033143866021423837056207677317517847011467076188001061138620310116832610271556685687769184940440093096226243113127523863162928128796969576356494654526264864467/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000049982993938734029907224829079297423001688561497319704539672479837135451639674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325442118" + }, + "improvement_over_pr1758": { + "rational": "49992441261979499696362137800026327686526580209099320247542619067215756927414399369818327775017/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000049992441261979499696362137800026327686526580209099320247542619067215756927414399369818327775017" + }, + "improvement_over_pr1699": { + "rational": "520962187209239869918375359363552509344315069998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000520962187209239869918375359363552509344315069998999999999999999999999999" + }, + "improvement_over_pr1712": { + "rational": "260481093604619934955841135680007884145727138631783638941299969772687284961029288600736779707649/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000520962187209239869911682271360015768291454277263567277882599939545374569922058577201473559415298" + }, + "improvement_over_previous_package": { + "rational": "519180477498421176118406871223998986170598784228341400200650717283025922262102542077285802551153/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000519180477498421176118406871223998986170598784228341400200650717283025922262102542077285802551153" + }, + "improvement_over_pkg_k2": { + "rational": "51745342858996030510807048169191627777122102965790395790280701170194526487548469132116575062403/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000051745342858996030510807048169191627777122102965790395790280701170194526487548469132116575062403" + }, + "gaussian_above_main": { + "rational": "1021454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.975137082054377236034688120730957031250000000000000000000000000000000000000000000000000000000000000000000000400390625E-111" + }, + "main_transform_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999995900454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999799826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125E-52" + }, + "global_coordinate_router_above_kappa": { + "rational": "20000000000000000000000019999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.00000000000000000000000099999999999999999999999999999999985E-52" + }, + "fused_gaussian_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999997943362111607104686909856190688550000000000000000000000000000000000000000000000000000000000000000000000000000123/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999899578228105815658540520321810964355468750000000000000000000000000000000000000000000000000000000000000000000006005859375E-52" + }, + "group_bit_router_above_kappa": { + "rational": "81920000000000000000000081919999999999999999999999999999995869448446428418747639424762754200000000000000000000000000000000000000000000000000000000000000000000000000000369/819200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.00000000000000000000000099999999999999999999999999999999994957822810581565854052032181096435546875000000000000000000000000000000000000000000000000000000000000000000000450439453125E-52" + }, + "group_scans_above_kappa": { + "rational": "2044457496678268357527054549354496000000000000000000204800000000000000000000204799999999999999999999999999999959/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99827026204993572144875710417700000000000000000000010000000000000000000000009999999999999999999999999999999997998046875" + }, + "boundary_algebraic_matrix_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999997948454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999899826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125E-52" + }, + "sparse_union_movement_above_kappa": { + "rational": "83200000000000000000000000000000000000000000000000020480000000000000000000020479999999999999999999999999999997948454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4062500000000000000000000000000000000000000000000001000000000000000000000000999999999999999999999999999999999899826857285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "polynomial_products_above_kappa": { + "rational": "4088914993356536715054109098708992000000000000000000409600000000000000000000409599999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.998270262049935721448757104177000000000000000000000100000000000000000000000099999999999999999999999999999999989990234375" + }, + "microbox_face_corrections_above_kappa": { + "rational": "78846228748339134178763527274677248000000000000000000102400000000000000000000102400000000000000000000000000000041/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "76.9982702620499357214487571041770000000000000000000001000000000000000000000001000000000000000000000000000000000400390625" + } + } + } + }, + "rejecting_controls": { + "struct_boundary_radix_union": { + "endpoint_equality": { + "complex_endpoint": { + "rational": "0", + "decimal": "0" + }, + "q_below_effective": { + "rational": "-1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5E-111" + }, + "q_below_internal": { + "rational": "-1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5E-111" + }, + "q_below_leaf": { + "rational": "-172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.72973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999E-119" + }, + "lambda_above_tau": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-111" + }, + "lambda_above_internal": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-111" + }, + "lambda_prime_above_lambda": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-111" + }, + "lambda_prime_above_leaf": { + "rational": "-172973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.72973795006427855124289582299999999999999999999999999999999999999999999999999999999999999999999999999999999E-119" + } + }, + "zero_layout_slack": { + "positive_layout_slack": { + "rational": "0", + "decimal": "0" + } + }, + "old_per_axis_scan": { + "old_per_axis_scan_above_kappa": { + "rational": "-7085006643463284945890901291007999999999999999999590399999999999999999999590399999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.001729737950064278551242895822999999999999999999999899999999999999999999999899999999999999999999999999999999989990234375" + } + }, + "full_cell_gauge": { + "unrecentered_group_gauge": { + "rational": "-204799999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999997949/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999979970703125" + } + }, + "full_key_sort": { + "unnecessary_full_key_sort_above_kappa": { + "rational": "-121599999999999999999999999999999999999999999999999979519999999999999999999979519999999999999999999999999999997951545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.5937499999999999999999999999999999999999999999999998999999999999999999999998999999999999999999999999999999999899977830214728113819826559396345214843749999999999999999999999999999999999999999999999999999999999999999999997998046875" + } + }, + "old_g_factor_union_row": { + "old_g_factor_union_row_above_kappa": { + "rational": "-121599999999999999999999999999999999999999999999999979519999999999999999999979519999999999999999999999999999995901545962797631771030047936437149999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.5937499999999999999999999999999999999999999999999998999999999999999999999998999999999999999999999999999999999799880173964728113819826559396345214843749999999999999999999999999999999999999999999999999999999999999999999997998046875" + } + }, + "old_theta_chirp_guard": { + "old_theta_chirp_guard": { + "rational": "-83554250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999994872454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.815959475900128557102485791645999999999999999999999999999999999999999999999999999999999999999999999999999999949926308957054377236034688120730957031250000000000000000000000000000000000000000000000000000000000000000000000400390625" + } + }, + "old_linear_guard": { + "old_linear_guard": { + "rational": "-185954250332173164247294545064550399999999999999999999999999999999999999999999999999999999999999999999999999991796454037202368228969952063562850000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.9079797379500642785512428958229999999999999999999999999999999999999999999999999999999999999999999999999999999599436232285271886180173440603654785156250000000000000000000000000000000000000000000000000000000000000000000002001953125" + } + }, + "old_union_tag_2beta": { + "old_union_tag_2beta": { + "rational": "-2047999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999993994140625" + } + }, + "matrix_below_strassen": { + "strassen_integer_power_gap": { + "rational": "-423", + "decimal": "-423" + } + }, + "halo_too_short": { + "halo_covers_generic_inverse_radius": { + "rational": "-3", + "decimal": "-3" + } + }, + "core_too_small": { + "microbox_halo_volume": { + "rational": "-4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "microbox_face_corrections_above_kappa": { + "rational": "-3073771251660865821236472725322751999999999999999999897599999999999999999999897599999999999999999999999999999959/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-3.0017297379500642785512428958229999999999999999999998999999999999999999999998999999999999999999999999999999999599609375" + } + }, + "group_equals_dimension": { + "group_below_dimension": { + "rational": "0", + "decimal": "0" + }, + "group_key_fits_record": { + "rational": "0", + "decimal": "0" + }, + "membership_arithmetic_fits_record": { + "rational": "-41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.0009765625E-110" + } + }, + "epsilon_equals_one": { + "epsilon_below_one": { + "rational": "0", + "decimal": "0" + }, + "global_gamma_power_slack": { + "rational": "-1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1E-110" + }, + "actual_logarithmic_gamma_guard": { + "rational": "0", + "decimal": "0" + }, + "source_axis_superpolynomial": { + "rational": "0", + "decimal": "0" + }, + "gaussian_above_main": { + "rational": "-10637888392895313090143809311449999999999999999999999999999999999999999999999999999999999999999999999999999877/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5.19428144184341459479678189035644531249999999999999999999999999999999999999999999999999999999999999999999993994140625E-113" + } + }, + "epsilon_not_above_r0_slack": { + "global_gamma_power_slack": { + "rational": "0", + "decimal": "0" + } + }, + "beta_below_gaussian_window": { + "gaussian_above_main": { + "rational": "-428627995544607950003507569567849999999999999999999999999999999999999999999999999999999999999999999999999971341/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.0929101344951560058765018045305175781249999999999999999999999999999999999999999999999999999999999999999998600634765625E-111" + } + }, + "beta_above_membership_window": { + "membership_arithmetic_fits_record": { + "rational": "0", + "decimal": "0" + } + } + } + }, + "pr1673_kappa": { + "rational": "1677160151714381/1000000000000000000", + "decimal": "0.001677160151714381" + }, + "improvement_over_pr1673": { + "rational": "525777983498975512428958229999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000525777983498975512428958229999999999999999999998999999999999999999999999" + }, + "source_sha256": { + "new/SPEC.json": "c7e00c7f5dd88eaa8cea6f22aac676dccfa81eed642810491f56e87a646a34eb", + "CLAIM.json": "ebc53e1c35487511741bdbbbd363215af6d03306cbb31080ab64f2def251ba9d" + } +} diff --git a/research/t740-six-skip-precision30/evidence/VALIDATION.json b/research/t740-six-skip-precision30/evidence/VALIDATION.json new file mode 100644 index 0000000000..cbe3c735ec --- /dev/null +++ b/research/t740-six-skip-precision30/evidence/VALIDATION.json @@ -0,0 +1,76 @@ +{ + "admission_sha256": "796ac8d3d6c1ee8a28a034ded3a27ea59ee383b940d8b2626151f80d36636998", + "baseline_admission_sha256": "63ece4778470eebd62edb7af91470a999931b039ea0b71c0a70f56313ea88d16", + "baseline_complete": true, + "baseline_native_receipt_sha256": "cd63034001536700953fd0b0e4d21e7a85cc76a2b97bd14d8d729dfb4f051243", + "baseline_package_manifest_sha256": "cc47e8d61a656cd19765cec4c53a6b5dbdf0521b23ed0ee626bc4bc069ab10ae", + "baseline_release_projection": { + "kappa_decimal": "0.0017297379500642785512419999999999999999999998999999999999999999999999", + "manifest_sha256": "cc47e8d61a656cd19765cec4c53a6b5dbdf0521b23ed0ee626bc4bc069ab10ae", + "status": "PASS_RELEASE" + }, + "baseline_terminal_receipt_sha256": "502579bbfa32792048fd4d2754a01ba8ba4bb888b446d7c1d9b1413c7cc18d90", + "candidate_admission_sha256": "796ac8d3d6c1ee8a28a034ded3a27ea59ee383b940d8b2626151f80d36636998", + "candidate_checkpoint_scope": "Nomination geometry prefix reused; corrected assembly/freeze/independent executed. Final strict release is fresh.", + "candidate_complete": true, + "candidate_native_receipt_sha256": "cd63034001536700953fd0b0e4d21e7a85cc76a2b97bd14d8d729dfb4f051243", + "candidate_package_manifest_sha256": "1f4aa207994e0ce10a10ceccc413676459502d128410ed9102ad82dd38872768", + "candidate_release_projection": { + "kappa_decimal": "0.0017297379500642785512428958229999999999999999999998999999999999999999999999", + "manifest_sha256": "1f4aa207994e0ce10a10ceccc413676459502d128410ed9102ad82dd38872768", + "status": "PASS_RELEASE" + }, + "candidate_terminal_receipt_sha256": "d15f6fff64cbefe9a61ea2b4f3c6c2344643c0db6c00c76d21c8e61bfaa5108a", + "controller_controls": [ + "alias two whole owners", + "helper on active data family", + "owner in private namespace", + "wrong residual width", + "wrong spectator coordinate", + "omit idle remainder", + "omit private zero buffers", + "private buffer aliases data", + "pooled slots exchange invocation time (equal widths)", + "pooled slot time shifted", + "understate physical reserve", + "extra: wrong provider at its invocation", + "extra: stale per-call local program hash", + "extra: stale serialized provider program", + "extra: unbound residual adapter hash", + "extra: wrong per-call residual width", + "extra: wrong sweep provider", + "extra: entering helper width silently restored to nine", + "gauge44: wrong provider at its invocation", + "gauge44: stale per-call local program hash", + "gauge44: stale serialized provider program", + "gauge44: unbound residual adapter hash", + "gauge44: wrong per-call residual width", + "gauge44: wrong sweep provider", + "gauge44: entering helper width silently restored to nine" + ], + "controller_summary_note": "The unchanged supplier summary retains the historical controller=15 field; the actual completed ASYNC-AUDIT lists25 distinct rejected controls. Original source and receipts are unchanged; this evidence reports the actual list.", + "controls": { + "admission": 139, + "bit": 12, + "controller": 25, + "geometry": 6, + "independent_owner": 8 + }, + "files": { + "DERIVATION.json": "0bde4d8a12810779be7cd599b0b24de69bcaf622c86f2b98eb457c0eec684ca8", + "OUTER-LEDGER.json": "a0f285aa6bf65f10a7cd3c68a304b48e3a7a31f84597b04e149c1dc674e3816a" + }, + "gain": "8958230000000000000000999999000000000000000000999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "inherited_supplier_summary_controls": { + "admission": 139, + "bit": 12, + "controller": 15, + "geometry": 6, + "independent_owner": 8 + }, + "kappa": "17297379500642785512428958229999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "previous": "17297379500642785512419999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "projection_scope": "Terminal status, exact point and manifest projected from authentic completed receipts; machine timing omitted. Original bytes remain unchanged privately and are SHA256-bound. Registered replay checks finite evidence; reproduce.py performs the full changed release.", + "release_sha256": "d15f6fff64cbefe9a61ea2b4f3c6c2344643c0db6c00c76d21c8e61bfaa5108a", + "status": "PASS_T740_SIX_SKIP_PRECISION30_COMPLETE_RELEASE" +} diff --git a/research/t740-six-skip-precision30/reproduce.py b/research/t740-six-skip-precision30/reproduce.py new file mode 100644 index 0000000000..c2d8ff5a68 --- /dev/null +++ b/research/t740-six-skip-precision30/reproduce.py @@ -0,0 +1,192 @@ +"""Source-bound precision refinement; complete baseline and changed release are mandatory. + +Credit Nick Petalas/PR3054, dcharb78/PR3042 and the retained native/outer lineage. +Substantial OpenAI Codex assistance. Apache-2.0.""" + +import ast +import hashlib +import importlib.util +import json +import os +import subprocess +import sys +from fractions import Fraction as Q +from pathlib import Path +import argparse + +P = Path(__file__).resolve().parent +ROOT = P.parents[1] +parser = argparse.ArgumentParser(description=__doc__) +parser.add_argument("--baseline-work", type=Path, required=True) +parser.add_argument("--work", type=Path, required=True) +a = parser.parse_args() +BASELINE = a.baseline_work.resolve() +WORK = a.work.resolve() +PKG = ROOT / "research/rank7-t740-carrier-skips" + + +def need(ok, msg): + if not ok: + raise ValueError(msg) + + +def read(p): + return json.loads(p.read_bytes()) + + +def sha(p): + return hashlib.sha256(p.read_bytes()).hexdigest() + + +def save(p, x): + p.write_text(json.dumps(x, indent=2, sort_keys=True) + "\n") + + +def load(p, name): + spec = importlib.util.spec_from_file_location(name, p) + m = importlib.util.module_from_spec(spec) + spec.loader.exec_module(m) + return m + + +need(os.name == "posix" and not sys.flags.optimize, "POSIX and assertions required") +need(not WORK.is_relative_to(P), "replay workspace outside published package") +binding = load(P / "verify.py", "refinement_source_binding") +binding.authenticate() +sys.path.insert(0, str(PKG)) +m = load(PKG / "reproduce.py", "credited_3054_reproduce") +r = read(BASELINE / "RESULT.json") +stages = read(BASELINE / "STAGES.json") +need( + r["status"] == "PASS_T740_SIX_SKIP_COMPLETE_RELEASE", "mandatory completed baseline" +) +for s in stages: + need( + s["exit_code"] == 0 + and sha(BASELINE / (s["stage"] + ".log")) == s["log_sha256"], + "baseline stage and exact log", + ) +need( + m.check_release(BASELINE, BASELINE / "pr3042", r["fill_sha256"], stages) == r, + "full source-bound baseline rederived", +) +need(not WORK.exists(), "fresh refinement work") +WORK.mkdir() +recipe = read(BASELINE / "RECIPE.json")["commands"] +derive = [c.copy() for n, c in recipe if n == "derive-closed-adapters"] +need(len(derive) == 1, "one unchanged adapter derivation") +c = derive[0] +need( + c == binding.expected_command("derive-closed-adapters", BASELINE, sys.executable), + "exact source-pinned derivation command; only workspace/interpreter paths relocate", +) +c[c.index("--out") + 1] = str(WORK / "adapters-original") +subprocess.run(c, check=True) +original = BASELINE / "run/adapters/admit_extension.py" +reference = WORK / "adapters-original/admit_extension.py" +need( + reference.read_bytes() == original.read_bytes(), + "fresh original adapter derivation equality", +) +body = reference.read_text() +edits = read(P / "PRECISION-EDITS.json") +edits = [x for x in edits if not x["old"].startswith(("COMPARISONS = {", "choices="))] +need(len(edits) == 6, "only declared precision changes") +for e in edits: + need(body.count(e["old"]) == 1, "one exact precision preimage: " + e["old"]) + body = body.replace(e["old"], e["new"]) + + +def checks(t): + tree = ast.parse(t) + return sum(isinstance(x, ast.Assert) for x in ast.walk(tree)), sum( + isinstance(x, ast.Call) and isinstance(x.func, ast.Name) and x.func.id == "need" + for x in ast.walk(tree) + ) + + +need( + checks(body) == checks(reference.read_text()), + "all assertion and explicit check counts retained", +) +adapter = WORK / "admit_precision30.py" +adapter.write_text(body) +save( + WORK / "DERIVATION.json", + dict( + reference_sha256=sha(reference), + candidate_sha256=sha(adapter), + replacements=edits, + ), +) +command = [c.copy() for n, c in recipe if n == "complete-admission"] +need(len(command) == 1, "one complete admission command") +command = command[0] +need( + command == binding.expected_command("complete-admission", BASELINE, sys.executable), + "exact source-pinned complete admission command", +) +command[:3] = [sys.executable, "-B", str(adapter)] +command[command.index("--work") + 1] = str(WORK / "candidate") +sys.path.insert(0, str(P)) +nom = load(P / "verify.py", "refinement_arithmetic").calculate() +need(Q(r["kappa"]) == Q(nom["previous"]), "exact current comparison point") +env = dict( + os.environ, + PYTHONDONTWRITEBYTECODE="1", + PYTHONINTMAXSTRDIGITS="0", + OPENBLAS_NUM_THREADS="1", + OMP_NUM_THREADS="1", +) +for k in ( + "PYTHONOPTIMIZE", + "PYTHONPATH", + "WITNESS_SPEC", + "WITNESS_RECORD", + "WITNESS_DISCOVER", +): + env.pop(k, None) +print("START_FULL_PRECISION30_ADMISSION", flush=True) +with (WORK / "complete-admission.log").open("w") as log: + subprocess.run(command, check=True, env=env, stdout=log, stderr=subprocess.STDOUT) +a = read(WORK / "candidate/RESULT.json") +release = read(WORK / "candidate/release/RELEASE-RECEIPT.json") +need( + a["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" + and release["status"] == "PASS_RELEASE", + "complete actual candidate release", +) +need( + Q(a["kappa"]) == Q(nom["kappa"]) == Q(release["kappa_decimal"]) > Q(r["kappa"]), + "actual exact improved released point", +) +for k in ( + "profile", + "fill_sha256", + "order_sha256", + "dispatch_sha256", + "source_manifest_sha256", + "native_receipt_sha256", +): + need( + a[k] == read(BASELINE / "run/candidate/RESULT.json")[k], + "unchanged physical/source/native input " + k, + ) +need( + a["release_receipt_sha256"] == sha(WORK / "candidate/release/RELEASE-RECEIPT.json"), + "actual terminal receipt hash", +) +save( + WORK / "RESULT.json", + dict( + status="PASS_T740_SIX_SKIP_PRECISION30_COMPLETE_RELEASE", + kappa=a["kappa"], + previous=r["kappa"], + gain=str(Q(a["kappa"]) - Q(r["kappa"])), + baseline_complete=True, + candidate_complete=True, + admission_sha256=sha(WORK / "candidate/RESULT.json"), + release_sha256=sha(WORK / "candidate/release/RELEASE-RECEIPT.json"), + ), +) +print("PASS_T740_SIX_SKIP_PRECISION30_COMPLETE_RELEASE", a["kappa"], flush=True) diff --git a/research/t740-six-skip-precision30/requirements-full.txt b/research/t740-six-skip-precision30/requirements-full.txt new file mode 100644 index 0000000000..1c940743f4 --- /dev/null +++ b/research/t740-six-skip-precision30/requirements-full.txt @@ -0,0 +1,5 @@ +numpy==1.26.4 +scipy==1.15.3 +sympy==1.14.0 +mpmath==1.3.0 +gmpy2==2.3.2 diff --git a/research/t740-six-skip-precision30/seal.py b/research/t740-six-skip-precision30/seal.py new file mode 100644 index 0000000000..e4638d2fc1 --- /dev/null +++ b/research/t740-six-skip-precision30/seal.py @@ -0,0 +1,151 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Derive privacy-preserving evidence only from completed authenticated replays. + +Terminal projections omit machine timing; original receipts remain unchanged +in the external workspace and are committed to by their exact SHA256 digests. +Substantial OpenAI Codex assistance. Apache-2.0. +""" + +import argparse +import shutil +import sys + +import verify as v + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--baseline-work", type=v.Path, required=True) + parser.add_argument("--work", type=v.Path, required=True) + a = parser.parse_args() + baseline, work = a.baseline_work.resolve(), a.work.resolve() + v.authenticate() + sys.path.insert(0, str(v.ROOT / "research/rank7-t740-carrier-skips")) + original = v.load( + v.ROOT / "research/rank7-t740-carrier-skips/reproduce.py", + "credited_baseline_seal", + ) + result = v.read(baseline / "RESULT.json") + stages = v.read(baseline / "STAGES.json") + for stage in stages: + v.need( + stage["exit_code"] == 0 + and v.sha(baseline / (stage["stage"] + ".log")) == stage["log_sha256"], + "authentic completed baseline stage", + ) + v.need( + original.check_release( + baseline, baseline / "pr3042", result["fill_sha256"], stages + ) + == result, + "completed baseline fully rederived", + ) + checked = v.read(work / "RESULT.json") + v.completion(checked) + v.need( + v.sha(work / "candidate/RESULT.json") == checked["admission_sha256"] + and v.sha(work / "candidate/release/RELEASE-RECEIPT.json") + == checked["release_sha256"], + "completed refinement result authenticates actual admission and terminal receipt", + ) + derivation = v.read(work / "DERIVATION.json") + v.need( + derivation["replacements"] == v.read(v.P / "PRECISION-EDITS.json") + and derivation["reference_sha256"] + == v.sha(baseline / "run/adapters/admit_extension.py") + and derivation["candidate_sha256"] == v.sha(work / "admit_precision30.py"), + "exact declared source derivation", + ) + arithmetic = v.calculate() + for key in ("kappa", "previous", "gain"): + v.need(v.Q(checked[key]) == v.Q(arithmetic[key]), "exact completed refinement") + evidence = dict(checked) + for key, directory in ( + ("baseline", baseline / "run/candidate"), + ("candidate", work / "candidate"), + ): + admission = v.read(directory / "RESULT.json") + receipt_path = directory / "release/RELEASE-RECEIPT.json" + receipt = v.read(receipt_path) + v.need( + admission["status"] + == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "actual complete admission", + ) + v.need( + admission["release_receipt_sha256"] == v.sha(receipt_path) + and admission["package_manifest_sha256"] == receipt["manifest_sha256"], + "actual terminal receipt and admitted manifest", + ) + for stage in admission["stages"]: + v.need( + stage["exit_code"] == 0 + and v.sha(directory / (stage["name"] + ".log")) == stage["log_sha256"], + "all actual admission stages and logs", + ) + evidence[key + "_release_projection"] = { + field: receipt[field] + for field in ("status", "kappa_decimal", "manifest_sha256") + } + evidence[key + "_terminal_receipt_sha256"] = v.sha(receipt_path) + evidence[key + "_admission_sha256"] = v.sha(directory / "RESULT.json") + evidence[key + "_package_manifest_sha256"] = admission[ + "package_manifest_sha256" + ] + evidence[key + "_native_receipt_sha256"] = admission["native_receipt_sha256"] + if "checkpoint_scope" in admission: + evidence[key + "_checkpoint_scope"] = admission["checkpoint_scope"] + controls = v.read(work / "candidate/release/verify/RESULT.json") + audit = v.read( + work / "candidate/release/verify/strict/global/audit/ASYNC-AUDIT.json" + ) + v.need( + audit["status"] + == "PASS_INDEPENDENT_ASYNC_WHOLE_OWNER_CONTROLLER_PHASES_AND_SPECTATORS" + and audit["mutation_controls_run"] is True, + "actual complete controller mutation audit", + ) + names = audit["mutations_rejected"] + v.need(len(names) == len(set(names)) == 25, "all25 actual controller controls") + baseline_audit = v.read( + baseline / "run/candidate/release/verify/strict/global/audit/ASYNC-AUDIT.json" + ) + expected_names = v.read( + v.ROOT / "research/rank7-t740-carrier-skips/evidence/ASYNC-AUDIT.json" + )["mutations_rejected"] + v.need( + baseline_audit["mutations_rejected"] == names == expected_names, + "both completed releases retain every named original controller control", + ) + evidence["inherited_supplier_summary_controls"] = controls["controls"] + evidence["controller_controls"] = names + evidence["controls"] = dict(controls["controls"], controller=len(names)) + evidence["controller_summary_note"] = ( + "The unchanged supplier summary retains the historical controller=15 field; " + "the actual completed ASYNC-AUDIT lists25 distinct rejected controls. " + "Original source and receipts are unchanged; this evidence reports the actual list." + ) + evidence["projection_scope"] = ( + "Terminal status, exact point and manifest projected from authentic completed receipts; " + "machine timing omitted. Original bytes remain unchanged privately and are SHA256-bound. " + "Registered replay checks finite evidence; reproduce.py performs the full changed release." + ) + out = v.P / "evidence" + v.need(not out.exists(), "fresh evidence output") + out.mkdir() + for source, name in ( + (work / "candidate/package/outer/LEDGER.json", "OUTER-LEDGER.json"), + (work / "DERIVATION.json", "DERIVATION.json"), + ): + shutil.copyfile(source, out / name) + evidence["files"] = {p.name: v.sha(p) for p in out.iterdir()} + (out / "VALIDATION.json").write_text( + v.json.dumps(evidence, indent=2, sort_keys=True) + "\n" + ) + v.run() + print("PASS_SEALED_COMPLETE_REFINEMENT") + + +if __name__ == "__main__": + main() diff --git a/research/t740-six-skip-precision30/test_verify.py b/research/t740-six-skip-precision30/test_verify.py new file mode 100644 index 0000000000..2b1fabba36 --- /dev/null +++ b/research/t740-six-skip-precision30/test_verify.py @@ -0,0 +1,93 @@ +"""Reject incomplete releases and damaged actual outer evidence. + +Substantial OpenAI Codex assistance. Apache-2.0. +""" + +import copy +import os +import subprocess +import sys +import tempfile +import unittest + +import verify as v + + +class EvidenceControls(unittest.TestCase): + @unittest.skipUnless(os.name == "posix", "full replay uses POSIX process cleanup") + def test_cli_refuses_preflight_baseline(self): + with tempfile.TemporaryDirectory() as directory: + root = v.Path(directory) + baseline = root / "baseline" + baseline.mkdir() + (baseline / "RESULT.json").write_text( + v.json.dumps({"status": "PREFLIGHT_ONLY_NOT_A_RELEASE"}) + ) + (baseline / "STAGES.json").write_text("[]") + output = root / "candidate" + result = subprocess.run( + [ + sys.executable, + "-B", + str(v.P / "reproduce.py"), + "--baseline-work", + str(baseline), + "--work", + str(output), + ], + capture_output=True, + text=True, + timeout=30, + ) + self.assertNotEqual(result.returncode, 0) + self.assertIn("mandatory completed baseline", result.stderr) + self.assertFalse(output.exists()) + + def test_original_source_derivation(self): + baseline, candidate = v.expected_adapter_hashes() + valid = dict( + reference_sha256=baseline, + candidate_sha256=candidate, + replacements=v.read(v.P / "PRECISION-EDITS.json"), + ) + v.check_derivation(valid) + for key in ("reference_sha256", "candidate_sha256"): + with self.subTest(key=key), self.assertRaises(ValueError): + v.check_derivation(dict(valid, **{key: "0" * 64})) + + def test_incomplete_releases(self): + valid = dict( + baseline_complete=True, + candidate_complete=True, + status="PASS_T740_SIX_SKIP_PRECISION30_COMPLETE_RELEASE", + ) + v.completion(valid) + for key in ("baseline_complete", "candidate_complete"): + for value in (False, 1, "true"): + with self.subTest(key=key, value=value): + bad = dict(valid, **{key: value}) + with self.assertRaises(ValueError): + v.completion(bad) + with self.assertRaises(ValueError): + v.completion(dict(valid, status="PREFLIGHT_ONLY_NOT_A_RELEASE")) + + def test_actual_outer_mutants(self): + path = v.ROOT / "research/rank7-t740-carrier-skips/evidence/OUTER-LEDGER.json" + actual = v.read(path) + point = actual["rows"]["struct_boundary_radix_union"]["kappa"]["rational"] + v.check_ledger(actual, point) + with self.assertRaises(ValueError): + v.check_ledger(actual, v.Q(point) + v.Q(1, 10**30)) + zero = copy.deepcopy(actual) + checks = zero["rows"]["struct_boundary_radix_union"]["strict_checks"] + checks[next(iter(checks))]["rational"] = "0" + with self.assertRaises(ValueError): + v.check_ledger(zero, point) + missing = copy.deepcopy(actual) + missing["rejecting_controls"]["struct_boundary_radix_union"].popitem() + with self.assertRaises(ValueError): + v.check_ledger(missing, point) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/t740-six-skip-precision30/verify.py b/research/t740-six-skip-precision30/verify.py new file mode 100644 index 0000000000..93c9f09c5d --- /dev/null +++ b/research/t740-six-skip-precision30/verify.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact arithmetic refinement; finite receipt checks do not rerun native chains. + +Credit the PR3054/3042 construction and both retained rational engines. +Substantial OpenAI Codex assistance. No independent arithmetic invention claimed. +""" + +import hashlib +import importlib.util +import json +from fractions import Fraction as Q +from pathlib import Path +from pathlib import PurePosixPath + +P = Path(__file__).resolve().parent +ROOT = P.parents[1] +PROFILE = { + 1: 16376940, + 2: 4741920, + 3: 1594737, + 4: 719280, + 5: 137085, + 8: 53280, + 48: 281903, +} + + +def need(ok, msg): + if not ok: + raise ValueError(msg) + + +def read(p): + return json.loads(p.read_bytes()) + + +def sha(p): + return hashlib.sha256(p.read_bytes()).hexdigest() + + +def load(p, name): + spec = importlib.util.spec_from_file_location(name, p) + m = importlib.util.module_from_spec(spec) + spec.loader.exec_module(m) + return m + + +def authenticate(): + for r in read(P / "SOURCES.json")["files"]: + if r["usage"] == "input": + need(sha(ROOT / r["path"]) == r["sha256"], "source drift: " + r["path"]) + + +def calculate(): + authenticate() + root = load(ROOT / "research/rank7-joint-endframes/tools/root.py", "credited_root") + other = load( + ROOT / "research/two-sided-helper-extraction/tools/audit_moment.py", + "credited_other", + ) + lo, hi = root.kappa_from_profile(PROFILE, 740, digits=35) + c = Q((lo * 10**30).__floor__(), 10**30) + k = c - Q(1, 10**52) - Q(1, 10**76) + old = Q( + read(ROOT / "research/rank7-t740-carrier-skips/evidence/ADMISSION-RESULT.json")[ + "kappa" + ] + ) + need(k > old and c <= lo < hi < c + Q(1, 10**30), "strict gain and root bracket") + need(sum(r * n for r, n in PROFILE.items()) == 65088 * 740, "complete rank mass") + for engine in (root, other): + need(engine.moment(PROFILE, c, 896 * 740)[1] < 1, "accepted endpoint") + need( + engine.moment(PROFILE, c + Q(1, 10**30), 896 * 740)[0] > 1, + "next grid rejected", + ) + for rank in (1, 48): + bad = dict(PROFILE) + bad[rank] += 1 + need(engine.moment(bad, c, 896 * 740)[0] > 1, "unpaid child rejected") + return { + key: str(v) + for key, v in dict( + kappa=k, + previous=old, + gain=k - old, + complex_lower=c, + root_lower=lo, + root_upper=hi, + ).items() + } + + +def completion(e): + need( + e["baseline_complete"] is True and e["candidate_complete"] is True, + "both actual complete releases required", + ) + need( + e["status"] == "PASS_T740_SIX_SKIP_PRECISION30_COMPLETE_RELEASE", + "complete refinement", + ) + + +def expected_adapter_hashes(): + original = ROOT / "research/two-sided-helper-extraction/tools/admit_channel408.py" + record = read( + ROOT / "research/rank7-t740-carrier-skips/evidence/ADAPTER-DERIVATION.json" + ) + inherited = record["changes"]["admit_extension.py"] + need(sha(original) == inherited["before_sha256"], "original strict source adapter") + body = original.read_text() + for edit in inherited["replacements"]: + need(body.count(edit["old"]) == 1, "inherited exact source preimage") + body = body.replace(edit["old"], edit["new"]) + baseline = hashlib.sha256(body.encode()).hexdigest() + need( + baseline == inherited["after_sha256"], + "complete published adapter reconstructed", + ) + for edit in read(P / "PRECISION-EDITS.json"): + need(body.count(edit["old"]) == 1, "exact precision source preimage") + body = body.replace(edit["old"], edit["new"]) + return baseline, hashlib.sha256(body.encode()).hexdigest() + + +def check_derivation(data): + baseline, candidate = expected_adapter_hashes() + need( + data["reference_sha256"] == baseline and data["candidate_sha256"] == candidate, + "exact complete source derivation hashes", + ) + need( + data["replacements"] == read(P / "PRECISION-EDITS.json"), + "exact six declared precision/selector changes", + ) + + +def expected_command(stage, baseline, python): + recipe = read(ROOT / "research/rank7-t740-carrier-skips/evidence/RECIPE.json")[ + "commands" + ] + derive = [command for name, command in recipe if name == "derive-closed-adapters"] + selected = [command for name, command in recipe if name == stage] + need(len(derive) == len(selected) == 1, "unique source-pinned recipe stage") + prefix = str(PurePosixPath(derive[0][2]).parents[2]) + command = [arg.replace(prefix + "/", str(baseline) + "/") for arg in selected[0]] + command[0] = python + return command + + +def check_evidence(e, arithmetic): + completion(e) + for k in ("kappa", "previous", "gain"): + need(Q(e[k]) == Q(arithmetic[k]), "exact evidence " + k) + need( + e["controls"] + == dict(admission=139, bit=12, controller=25, independent_owner=8, geometry=6), + "all actual inherited release controls", + ) + need( + len(e["controller_controls"]) == len(set(e["controller_controls"])) == 25, + "all25 actual controller rejections, not the inherited summary count", + ) + expected_controls = read( + ROOT / "research/rank7-t740-carrier-skips/evidence/ASYNC-AUDIT.json" + )["mutations_rejected"] + need( + e["controller_controls"] == expected_controls, + "every named original controller control retained", + ) + need( + e["inherited_supplier_summary_controls"] + == dict(admission=139, bit=12, controller=15, independent_owner=8, geometry=6), + "disclosed unchanged inherited supplier summary", + ) + for key, point in ( + ("baseline", arithmetic["previous"]), + ("candidate", arithmetic["kappa"]), + ): + projection = e[key + "_release_projection"] + need( + projection["status"] == "PASS_RELEASE" + and Q(projection["kappa_decimal"]) == Q(point), + "actual complete terminal projection: " + key, + ) + need( + projection["manifest_sha256"] == e[key + "_package_manifest_sha256"], + "actual admitted manifest: " + key, + ) + need( + e["baseline_native_receipt_sha256"] == e["candidate_native_receipt_sha256"], + "same authenticated unchanged native receipt", + ) + + +def check_ledger(ledger, kappa): + row = ledger["rows"]["struct_boundary_radix_union"] + need(Q(row["kappa"]["rational"]) == Q(kappa), "actual outer point") + need( + len(row["strict_checks"]) == 63 + and all(Q(v["rational"]) > 0 for v in row["strict_checks"].values()), + "all63 strict rows", + ) + bad = ledger["rejecting_controls"]["struct_boundary_radix_union"] + need( + len(bad) == 17 + and all( + v and all(Q(x["rational"]) <= 0 for x in v.values()) for v in bad.values() + ), + "all17 original outer controls", + ) + + +def run(): + arithmetic = calculate() + e = read(P / "evidence/VALIDATION.json") + check_evidence(e, arithmetic) + need( + set(e["files"]) == {"OUTER-LEDGER.json", "DERIVATION.json"}, + "complete declared evidence inventory", + ) + for name, h in e["files"].items(): + need(sha(P / "evidence" / name) == h, "evidence digest " + name) + check_derivation(read(P / "evidence/DERIVATION.json")) + check_ledger(read(P / "evidence/OUTER-LEDGER.json"), arithmetic["kappa"]) + print("PASS_T740_SIX_SKIP_PRECISION30", arithmetic["gain"]) + + +if __name__ == "__main__": + run()