diff --git a/research/p104-causal-buffer-split/APPLICATION.md b/research/p104-causal-buffer-split/APPLICATION.md new file mode 100644 index 0000000000..09060b813a --- /dev/null +++ b/research/p104-causal-buffer-split/APPLICATION.md @@ -0,0 +1,65 @@ +# Complete signed 17-stage application + +All direct CPython 3.14.7 certificate, native and application commands passed. +Final registered isolated Python 3.12.16 comparison passed all three commands; every frozen receipt field matched. This is finite +conditional evidence; the selected frontier and five assumptions are unchanged. + +The complete application has **110417 paid positions**, +**22325 productive fields**, rank surplus **1424** +and zero empty-root credit. Both source and candidate invoices are reconstructed +from their actual native words and the exact unchanged signed caller. +The claim is κ=.003642959019031, an increase of .000000550522162 over #7131. +Both directed price engines reject the predecessor invoice at this claim. + +| Fresh check | Result | +|---|---:| +|Ordinary source-unit work|779064884 < 1000000000| +|Precision context c|2362| +|Context height / mass exponent|406 / 1181| +|Native scale / fractional bits|1125 / 25| +|Owned banks per raw occurrence|901| +|Scalar service bound|42819968| +|Scalar step coefficient|44899990765568| +|Monomial map slots|298332| +|Elementary record bound|25436979648| +|Actual ambient / compiler cap|145 / 153| +|Maximum scalar numerator bits|24| +|Kstar / context-bound bits|14093 / 14104| + +The 17 native calls reserve all 53 owned labels each, **901 banks**, including +the two new buffers. Ordinary accounting uses all 56 native owned lifetimes; +the exact peak is 44. Every new INIT, CLEAR, ADD, SCALE, MOVE, independent +public input and conversion is included in the recorded service and route bills. +These are source-unit bounds and compiler substitutions, not measured machine +instruction counts or a top-level compiled benchmark. + +The unchanged caller has 4,783 symbolic events and its rational and integer +replays both pass. Its SHA256 remains +`255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`. Every one of the **3,039 paid/helper chart maps and 104 +main boundaries** is checked, with phase and owner bindings. The native check +separately covers five sets of 512 exact Gaussian columns and finite physical +routes. Newly used pair (734,237) is explicitly included. + +The fresh grid has maximal scaled mass +`814448574117075/8192` and fractional height 25; F24 is +rejected. Both precision paths use the new exact lifecycle census (56,44,53). +Every rounded native and caller envelope is recomputed with the added buffer +operations. Old receipts are not reused as evidence for the changed word. + +The complete gate has H=16502900000000000000000, written log power 2236, +and compiler gap 1/100000000000000000. All **54 strict and four functional** +outer conditions pass. The probe at the lower crossing is rejected; the written +claim and its accepted probe stay strictly below the crossing. No empty credit +is used. The separately checked 18-stage ingredient has ordinary work +852879688 and claim 182117753321/50000000000000; that is +not the final 17-stage application claim. + +`RESULT.json` stores every full application field. `NATIVE-RESULT.json` and +`CERTIFICATE.json` store the native and causal-observation evidence. The +registered hook compares all fields and authenticates the complete predecessor +closure. It does not establish independent human/formal acceptance, maintainer +admission, or a compiled top-level multiplication theorem. + +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +Credit Rohan Arun, Ali Romman, CubeJerry, Matarener, ToikY and every retained +source author; see NOTICE and the full frozen input closure. diff --git a/research/p104-causal-buffer-split/CERTIFICATE.json b/research/p104-causal-buffer-split/CERTIFICATE.json new file mode 100644 index 0000000000..a710f2790a --- /dev/null +++ b/research/p104-causal-buffer-split/CERTIFICATE.json @@ -0,0 +1,36 @@ +{ + "boundary_pairing": "1", + "candidate_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "controls": { + "gather_after_retirement": true, + "incomplete_paid_path": true, + "injection_before_retirement": true, + "omitted_gathers_observation": true, + "omitted_injections_observation": true, + "omitted_paid_midpoint_cost": true, + "retirement_before_last_gather": true, + "wrong_gathers_coefficient": true, + "wrong_injections_coefficient": true, + "wrong_productive_ranks": true + }, + "earliest_injection": 45280, + "gather_count": 7, + "injection_count": 1, + "latest_gather": 40066, + "neutral_paths": 7, + "paid_paths": 1, + "retirement_cut": 40066, + "source_sha256": "9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a", + "status": "PASS_EXACT_TIMED_OBSERVATIONS", + "vectors": { + "c": { + "320": "-1/2", + "331": "-1/2", + "335": "-1/2", + "411": "-1" + }, + "d": { + "331": "-2" + } + } +} diff --git a/research/p104-causal-buffer-split/DISCOVERY.json b/research/p104-causal-buffer-split/DISCOVERY.json new file mode 100644 index 0000000000..ef8a50579b --- /dev/null +++ b/research/p104-causal-buffer-split/DISCOVERY.json @@ -0,0 +1,44 @@ +{ + "source_commit": "666fd749ec465de7238633a0c2fd5ee3081477e0", + "native": "9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a", + "optional_search": { + "status": "EXACT_TEMPORAL_NOMINATION", + "counts": { + "observations_0": 14574, + "neutral_observations_0": 10436, + "observations_1": 22311, + "neutral_observations_1": 10436, + "frames": 1093, + "helpers": 621, + "prefix_pure": 127, + "suffix_pure": 103, + "basis_pairs": 47, + "causal_pairs": 47, + "causal_nonzero_pairs": 1, + "resident_pairs": 1, + "paid_paths_total": 7687, + "paid_paths_processed": 150 + }, + "frame_counts": [], + "seconds": 27.865705966949463, + "scope": "One complete contact-free path may pass through an existing intermediate frame, paying the exact two-leg histogram. All other observations come from neutral original-path retiming. Exact full rational baseline plus one outside-projected prefix/suffix vector; finite alphabet/basis nomination. Source group(3,127). All paid support, chronology and owned stock need constructive replay." + }, + "controls": { + "outside_cancellation": true, + "coefficient_reconstruction": true, + "contamination_rejected": true, + "earliest_collection_latest_delivery": true, + "paid_outside_projection": true + }, + "retained_neutral_path_ids": [ + 182, + 185, + 2563, + 2573, + 2583, + 2642, + 2671 + ], + "retained_paid_path_id": 149, + "scope": "Local exact one-paid-path nomination stopped at first positive. The public checker reconstructs the temporal certificate and entire word without trusting discovery. Full search code and unvisited paths are not required proof inputs." +} diff --git a/research/p104-causal-buffer-split/ENVIRONMENT.json b/research/p104-causal-buffer-split/ENVIRONMENT.json new file mode 100644 index 0000000000..c27ce4dbd8 --- /dev/null +++ b/research/p104-causal-buffer-split/ENVIRONMENT.json @@ -0,0 +1,12 @@ +{ + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "registered_replay": { + "python": "3.12.16", + "platform": "macOS-27.0.1-arm64-arm-64bit", + "result": "PASS all three commands; every certificate/native/application receipt field matched" + }, + "source_pins": "INPUTS.json and nested source manifests", + "parallelism": "No subagents; serial scientific replays; isolated worktree", + "completed_utc": "2026-11-11T00:00:38.265037+00:00" +} diff --git a/research/p104-causal-buffer-split/INPUTS.json b/research/p104-causal-buffer-split/INPUTS.json new file mode 100644 index 0000000000..8142bf6783 --- /dev/null +++ b/research/p104-causal-buffer-split/INPUTS.json @@ -0,0 +1,230 @@ +{ + "head": "666fd749ec465de7238633a0c2fd5ee3081477e0", + "prefix": "research/p104-output-rechart-composition", + "archive": "inputs/previous-composition.tar", + "archive_sha256": "efa1c93816997998dd61d214aa7c4e312a43e131b30a374ffccce2d5ccc91f71", + "files": [ + { + "path": "research/p104-output-rechart-composition/APPLICATION.md", + "size": 7341, + "sha256": "b1b3dc73d7804734f90d6ccd921f51b6b7dd6e1b5049bd9f40a3949045d303a3", + "git_blob": "6d999f62672a09fa6c10734f9afdb1f4baa3e5be" + }, + { + "path": "research/p104-output-rechart-composition/CHANGES.json", + "size": 7072, + "sha256": "75a32db6a3c73fbcf0e7e3ec5f2fa87ee21adbc0275f8ebdebec88d92cdd9d59", + "git_blob": "ec40963230ad56a2de886bb8001e4f3ef788ccc2" + }, + { + "path": "research/p104-output-rechart-composition/DISCOVERY.json", + "size": 983, + "sha256": "94552397ba27622be90755f7bab2e7cde14b8a9316665b2dc89baa609fe30ec8", + "git_blob": "25cd364abad03a6de4f68111b0c92331e8df4f8e" + }, + { + "path": "research/p104-output-rechart-composition/ENVIRONMENT.json", + "size": 673, + "sha256": "64e965248522f2d04c6c4c8d17c5c118833a640c61d86195b1ba362a3ef66eab", + "git_blob": "0fedc8fa56ec411dfc954c1cc1ae0ee8d191f81f" + }, + { + "path": "research/p104-output-rechart-composition/INPUTS.json", + "size": 6307, + "sha256": "3b0417e3f932fad96ff9c9c51510f7333d0e7c8dc7a0c0f4ffa3b97484437be5", + "git_blob": "6d7da5dadc3d2bf7620e5ebfa46ef367415789ef" + }, + { + "path": "research/p104-output-rechart-composition/NATIVE-RESULT.json", + "size": 75052, + "sha256": "c203566a32162b7c2aaee0bd132578ce58d243b2064a48152b800e7c22f3a313", + "git_blob": "5c0ba841f226c3ea5a2cf22b9b2606e1f10a6b1f" + }, + { + "path": "research/p104-output-rechart-composition/OVERLAP.md", + "size": 1556, + "sha256": "7940dc065f58e37771b0590f0a3c814ccdbb4f67237553a1e83585687abad0d5", + "git_blob": "b1612e2ce9a7baed7081f75effd36854eb80e440" + }, + { + "path": "research/p104-output-rechart-composition/PEER-SOURCES.json", + "size": 2641, + "sha256": "5b7440aa03bcf3b2c1886ada4fed1413424023a28393c8253bae0630406319e8", + "git_blob": "ca5294883c0e11e98997f9df6a035048b8003f87" + }, + { + "path": "research/p104-output-rechart-composition/PROOF.md", + "size": 6173, + "sha256": "f2d527d17240eb213dff00699511b1b6484d3b3fbdb9793971b93f3a8547fd0c", + "git_blob": "c9685a8a7b1597686e2b154b6f4643342f99ae12" + }, + { + "path": "research/p104-output-rechart-composition/README.md", + "size": 5843, + "sha256": "197b9d52c1366f30a2bf2d5304813823f47ec7f0ac2486f6e8d68c20abd0371d", + "git_blob": "c5e55e42b2011d97ad075f944c638086145bc190" + }, + { + "path": "research/p104-output-rechart-composition/REPLAY.txt", + "size": 4169, + "sha256": "03fd08a366955cbead236e6eaf857688d18f5289a243c688da3f138f6ad91837", + "git_blob": "73522f362302574a00928e6960dd5eebf3eeb86d" + }, + { + "path": "research/p104-output-rechart-composition/RESULT.json", + "size": 76806, + "sha256": "e4ae0c1cfa809cd780a6e22ce32528e7ca4b4e57f90abf91ad0bde97d30446ab", + "git_blob": "59ab2af00fd9e60f7027fbbb2a29c53f6143359e" + }, + { + "path": "research/p104-output-rechart-composition/SOURCES.json", + "size": 856, + "sha256": "8b58a30ae55396b8d108de4ee2c7c6ac75dc1096948c9ac3796c20b21b1c9372", + "git_blob": "c4150ae39789502a4adf89e8f5235995d458a72e" + }, + { + "path": "research/p104-output-rechart-composition/TASK.json", + "size": 12460, + "sha256": "56743e84c4d6db8ca9d62ecfe677f86a107d7794bf12f8f2de2481e4580685ae", + "git_blob": "ce00c6197c18cb8e168f4c0aa40814d7886c1f0e" + }, + { + "path": "research/p104-output-rechart-composition/TRANSFER-RESULT.json", + "size": 529, + "sha256": "3c51294b757de86fdf1fc16b6958257bc1b4e885f7f6ef4650b4deb4948b294d", + "git_blob": "7df85ba693ca75076035f703d6ba6f1035a1a8ea" + }, + { + "path": "research/p104-output-rechart-composition/TRANSFER.json", + "size": 29915, + "sha256": "c197f64cab6cd1ee542833d8f098103b5c3bfceb2e62231650cd49dc1e7dac81", + "git_blob": "a7fd6488446538e053987cbb34177117c77eeec8" + }, + { + "path": "research/p104-output-rechart-composition/VALIDATION.md", + "size": 3295, + "sha256": "4655fca62201a9ad6544df70145af5512844d46f423c768f54f888f0d22fc60e", + "git_blob": "756cd49b191dac2c38de05fa3e14f179eabfcd0c" + }, + { + "path": "research/p104-output-rechart-composition/VERIFY.json", + "size": 1543, + "sha256": "7889591feee7e96c3bf41074489525016aac4e4216198458a2baef0b660a6d56", + "git_blob": "dab71535b6a19267a0ab5cd6f43137cc5aba1975" + }, + { + "path": "research/p104-output-rechart-composition/WORD.json.gz", + "size": 370819, + "sha256": "2b9b9712addc38f441b434e8b2eca0cfefe5b54fdc1e174beed7f0c3435fa42d", + "git_blob": "5e2ae510e532e87a8888c739ab58fd6cba588c70" + }, + { + "path": "research/p104-output-rechart-composition/adapt.py", + "size": 3163, + "sha256": "7adb4ef927c75cdcb3e17aeef975b42aae7192a9ad5cc6e61e2b3160405e0768", + "git_blob": "4ec6f06e63e5833c041ad76b337c1145321e1075" + }, + { + "path": "research/p104-output-rechart-composition/construct.py", + "size": 2132, + "sha256": "56792894cff0607b2801b7ddc519e1f5ec1af8b70ce304a118e4b9467a939f10", + "git_blob": "70b54635320b3d705582a7b6569737d815f5c2bc" + }, + { + "path": "research/p104-output-rechart-composition/derive_grid.py", + "size": 1510, + "sha256": "ceb7a44ef19d72a16db7b43c65c85910d965499d1715436011de32af5d39dbb0", + "git_blob": "f8cb37f00bcd197d77bbb205dae3c1a40c0aa680" + }, + { + "path": "research/p104-output-rechart-composition/inputs/pr7130.tar", + "size": 10455040, + "sha256": "585abeb047f4c4b2d84a9a74c167fe9845850ed7521ea9f560031d5d5c82d084", + "git_blob": "5723c5b3657d820f9aaa01255617417a85ea858c" + }, + { + "path": "research/p104-output-rechart-composition/peer/CHANGES.json", + "size": 7072, + "sha256": "e645aaa73a169d74d83d93fa31e4fc0eb951b74d40be23e6fe41aee759c5e800", + "git_blob": "e1d530f9a5a76209a3bd504384246cab3d7e0752" + }, + { + "path": "research/p104-output-rechart-composition/peer/INPUTS.json", + "size": 5711, + "sha256": "a03561366baa758fbf81dddbaf5e84f10662273e207f543ba6b9065bf0575bbe", + "git_blob": "d7231ac870f4b529734fd6bb3b25ae8fe2d49d1b" + }, + { + "path": "research/p104-output-rechart-composition/peer/NATIVE-RESULT.json", + "size": 74965, + "sha256": "b0badb901d4b8d7e28a5fae4bae3b19bc87401b41fe39a830b1227de07b4ecbe", + "git_blob": "0b3bd194187d84acaf21a92b87f431b01a1abf9f" + }, + { + "path": "research/p104-output-rechart-composition/peer/PROOF.md", + "size": 3993, + "sha256": "80e648b5c1aa3a1a46d5264641a002ec29111ab5cfce4a47f6434740867317e6", + "git_blob": "2e17b59387477288f5f94d6e363dff00868c5af3" + }, + { + "path": "research/p104-output-rechart-composition/peer/README.md", + "size": 1873, + "sha256": "54d23d90492983ab764616ea9931c20125141c8df6f71130e7e6b74cf3be98e8", + "git_blob": "c848acf3f2a6f6615eaceab02645f870c4a21b32" + }, + { + "path": "research/p104-output-rechart-composition/peer/RESULT.json", + "size": 78679, + "sha256": "e6692aaeee16f7309bf6155e84f9b6b7f2e932ea3b31518834d5bd38db7465c5", + "git_blob": "1c91263862094c6fd73abc17253263c9a34f0f60" + }, + { + "path": "research/p104-output-rechart-composition/peer/WORD.json.gz", + "size": 365562, + "sha256": "26f4f14e42c22c4c88376a1581654a6c0e143fe5c0522b0475d826b3f76a4040", + "git_blob": "beb9a56b48bbf1e10c323db29dd6b793bd4b026d" + }, + { + "path": "research/p104-output-rechart-composition/peer/construct.py", + "size": 2132, + "sha256": "56792894cff0607b2801b7ddc519e1f5ec1af8b70ce304a118e4b9467a939f10", + "git_blob": "70b54635320b3d705582a7b6569737d815f5c2bc" + }, + { + "path": "research/p104-output-rechart-composition/price.py", + "size": 3642, + "sha256": "49deac5dcd265ad2ccdaffb53823fef1a4e5e450f8b11779d590da7376b403e7", + "git_blob": "aad42958ea47a381cbe3f58512ddd86c702ce7d6" + }, + { + "path": "research/p104-output-rechart-composition/source.py", + "size": 4784, + "sha256": "24123ca57918ad68cfc2a8a953dec33c93e166dff868e6ef8dc638fbd43b62d3", + "git_blob": "d3c35d14da65c7dd5a34dca03c7b1c82be66ce61" + }, + { + "path": "research/p104-output-rechart-composition/transfer.py", + "size": 1804, + "sha256": "2dedfaba6f7197f26db7983f14263a3771ed9e8bd99a2930b741d525443a1a00", + "git_blob": "e13e20a4bdaadde24e09277cce5638e107c162ca" + }, + { + "path": "research/p104-output-rechart-composition/verify.py", + "size": 3453, + "sha256": "d757c654b3ca666de47a17aeb4a15a779ae6d4cbea8f55af55528cab8bcfc4c0", + "git_blob": "b0bd280e44936a835af2ca6636b7e7e855746264" + }, + { + "path": "research/p104-output-rechart-composition/verify_native.py", + "size": 9956, + "sha256": "a8bfb0f3e6b582c0ab0dc2469f8761c3d1cf9061d5d03dd5c57e638739d0b55f", + "git_blob": "06ace4f351b61f84383e3718bfe8b0db386a6370" + }, + { + "path": "research/p104-output-rechart-composition/verify_transfer.py", + "size": 3664, + "sha256": "bcb9b9da59002462df9c9a4a5a868cf69055e1e5c549abd505e9382e3e986951", + "git_blob": "867e34fec8c563533c3f997a598e2aece36e7389" + } + ] +} diff --git a/research/p104-causal-buffer-split/NATIVE-RESULT.json b/research/p104-causal-buffer-split/NATIVE-RESULT.json new file mode 100644 index 0000000000..f970721a2f --- /dev/null +++ b/research/p104-causal-buffer-split/NATIVE-RESULT.json @@ -0,0 +1,3093 @@ +{ + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "new_pairs": [ + [ + 734, + 237 + ] + ], + "rechecked_pairs": [ + { + "columns": 512, + "pair": [ + 3, + 127 + ], + "rank": 9 + }, + { + "columns": 512, + "pair": [ + 3, + 237 + ], + "rank": 4 + }, + { + "columns": 512, + "pair": [ + 237, + 127 + ], + "rank": 5 + }, + { + "columns": 512, + "pair": [ + 734, + 127 + ], + "rank": 6 + }, + { + "columns": 512, + "pair": [ + 734, + 237 + ], + "rank": 1 + } + ], + "wrong_phase_rejected": true + }, + "controls": { + "extra_uncharged_owned_lifetime": true, + "gather_after_retirement": true, + "incomplete_paid_path": true, + "injection_before_retirement": true, + "insufficient_fractional_grid": true, + "insufficient_odd_grid": true, + "omitted_accumulator_init": true, + "omitted_gathers_observation": true, + "omitted_injections_observation": true, + "omitted_paid_midpoint_cost": true, + "omitted_retiring_output_frame": true, + "public_erasure_rejected": true, + "retirement_before_last_gather": true, + "wrong_boundary_scalar_coefficient": true, + "wrong_gathers_coefficient": true, + "wrong_injections_coefficient": true, + "wrong_move_source": true, + "wrong_productive_ranks": true + }, + "derived_grid": { + "coefficient_visits": 15457466, + "fractional_bits": 25, + "mass_witness": [ + 65219, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "814448574117075/8192", + "unscaled_maximum_mass": "10859314321561/122880" + }, + "forward": { + "coefficient_positions": 2390116, + "fractional_bits": 25, + "grid": 1125, + "rows": 1546 + }, + "gate": { + "BIT_margin": "12433493357993/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999999, + 0.9999999999999999 + ], + "claim": "182117753321/50000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8826188130107335, + 0.8826188130107335 + ], + "derivative_upper": -407182.5572954538, + "gamma": [ + 0.9500365762928551, + 0.9500365762928551 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "182117753321/50000000000000": [ + "124273361096405093736679119828523642152386274979860440984842635450680880733427/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62136680548202546868339559914261821076193137489930220492421317725340440367693/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364235506642007/100000000000000000": [ + "31068340274101845060086360062379977302468990836184170407011617771402439074883/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "15534170137050922530043180031189988651234495418092085203505808885701219537683/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18211775332100706133737027764777/5000000000000000000000000000000000": [ + -2.939359829325241e-29, + -2.939359829325241e-29 + ], + "364235506642007/100000000000000000": [ + 2.9499508632221194e-11, + 2.9499508632221194e-11 + ], + "36423550664201412267474055529553/10000000000000000000000000000000000": [ + 1.2022737151992645e-29, + 1.2022737151992645e-29 + ] + }, + "moment_margins": { + "18211775332100706133737027764777/5000000000000000000000000000000000": [ + "-367419978665655114339780632364664189449503624002577/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "-91854994666413778584945158091166047362375904685507/3125000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364235506642007/100000000000000000": [ + "1474975431611059730357321244549767053112190991038035205693036317666907/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "92185964475691233147332577784360440819511936939877200355814771170071/3125000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36423550664201412267474055529553/10000000000000000000000000000000000": [ + "30056842879981611126428617756607212426436191139569/2500000000000000000000000000000000000000000000000000000000000000000000000000000", + "120227371519926444505714471026428849705744768740949/10000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36423550664201412267474055529553/10000000000000000000000000000000000", + "18211775332100706133737027764777/5000000000000000000000000000000000" + ], + "tested": "364235506642007/100000000000000000", + "written_log_power": 2236 + }, + "grid": { + "dyadic_height": 25, + "maximum_scaled_mass": "814448574117075/8192", + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "odd_grid_lcm": 1125, + "opcodes": { + "ADD": 64531, + "CLEAR": 56, + "COPY": 1, + "INIT": 56, + "MOVE": 6273, + "SCALE": 3710 + }, + "owned_lifetimes": 56, + "owned_peak": 44, + "owned_rise_mass": 56, + "owned_rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + }, + "paid": { + "1": 3994, + "2": 854, + "3": 827, + "4": 224, + "5": 342, + "6": 15, + "7": 11, + "8": 6 + } + }, + "invoice": { + "P": { + "1": 72276, + "16": 416, + "2": 15372, + "24": 416, + "3": 14886, + "32": 416, + "4": 4032, + "40": 416, + "48": 416, + "5": 6156, + "56": 416, + "6": 270, + "64": 416, + "7": 198, + "8": 780, + "9": 32 + }, + "S": 1520, + "T": { + "1": 288, + "145": 208, + "17": 416, + "2": 360, + "25": 416, + "3": 846, + "33": 416, + "4": 3942, + "41": 416, + "49": 416, + "5": 1350, + "57": 416, + "6": 774, + "65": 416, + "7": 324, + "73": 416, + "8": 630, + "9": 11576 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036423550664201412267474055529553290289737678202927399589210149709", + "raw_crossing": "0.0036423550664201412267474055529553290289737678202927399589210149709" + }, + "limitations": [ + "Five inherited framework assumptions remain.", + "Source-aware retained engines are not independent human/formal acceptance.", + "The complete 17-stage application is checked separately." + ], + "native": { + "bad_inputs": [], + "events": 74627, + "helpers": { + "1": 16, + "2": 20, + "3": 47, + "4": 219, + "5": 75, + "6": 43, + "7": 18, + "8": 35, + "9": 620 + }, + "lifetimes": 56, + "owned_peak": 44, + "paid": { + "1": 3994, + "2": 854, + "3": 827, + "4": 224, + "5": 342, + "6": 15, + "7": 11, + "8": 6 + }, + "public": 1493, + "rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + } + }, + "ordinary": { + "caller_items": { + "A": { + "envelope": 124674048, + "field_boundary": 94848, + "fused_routes": 0, + "idle_routes": 185472000, + "output_routes": 229056000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 39515136, + "field_boundary": 7904, + "fused_routes": 1168000, + "idle_routes": 19552000, + "output_routes": 19088000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 619786080, + "conservative_total": 852879688, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 224, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 147120312, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2794896, + "raw_upper": 834916536, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2186, + "moves": 6273, + "owned_lifetime": 224, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9883000, + "scalar_upper": 2068692 + }, + "physical_checks": [ + "verify_host3_odd.py", + "physical.py" + ], + "precision": { + "Kstar_bits": 14093, + "caller": { + "denominator_height": 431, + "maximum_mass": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "pre_joint_height": 426, + "pre_joint_mass": "766527916529583301313228867197686200815349463045311717713050641430930492401493758087731346459407655106441982454343595473292801327075604294093436993244143470221321807686760749419510412771973080166736111/17179869184" + }, + "context_c": 1342, + "context_height": 451, + "context_mass_bits": 671, + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "45956159174072599700841582644791226032878246665742197512850210148957847086108563258880912378518411647758984921374583775627721903027855539985608524545788884385074028054962822941002911344421979827194338019317181669291086596879430115113578146646042105680303478329302401769326614809992435001600144772164326296955809382451/236574025616993083824920739000090624000000000000000000000", + "strict_power_of_two": 865, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "29616632735008889987723864669486932497070637831470618474927110629250565845181480463803853254183484427226999741924183858410142264176797069732759917922574584434237862536072382090671054557074313616044736234650520708908465285927889686274454991039162345983077755869741179076957394063036352251163125788931388495174547079429191/1135555322961566802359619547200434995200000000000000000000", + "strict_power_of_two": 872, + "witness": { + "cut": 5112, + "factor": "1", + "kind": "public-return", + "register": 75 + } + }, + "M_caller": { + "exact": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "strict_power_of_two": 619, + "witness": { + "cut": 5076, + "event": 5075, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "M_context": { + "exact": "8832691723967798289922197470035262921498993945278770630805548932350443022339137237348394756037067377617408111948540296390473446216190245494867024607875563286773391333286910057932340423776456743453667577760460234415931248119975943926737482611781145310344503954581319185601388488881504974016277388932773258487912488111169909/757036881974377868239746364800289996800000000000000000000", + "strict_power_of_two": 881, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + }, + "M_joint_entrance": { + "exact": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "strict_power_of_two": 612, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Sigma_caller": { + "exact": "29616632735008889987723864669486932497070637831470618474927110629250565845181480463803853254183484427226999741924183858410142264176797069732759917922574584434237862536072382090671054557074313616044736234650520708908465285927889686274454991039162345983077755869741179076957394063036352251163125788931388495174547079429191/1135555322961566802359619547200434995200000000000000000000", + "strict_power_of_two": 872, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "91930729022619271802726300544541379868022346387049314900004884115869639906200374749192071668262009319104958344306066704568048819683866747940140625835140470893922190508611829420127475283746104833035905498297173170408985190911731411030544630768758711990001404336201806149751651487661069676257529638109564854887731981091828900231477531798138593825936009759355472454943277930280770072893019854393846800211952580120307639037846900765032139205137563538145297/655866440585504295186659233010595682288897598376131487118386096242688000000000000000000000000000000000000000000", + "strict_power_of_two": 1134, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19674, + "helper_allocation_premise": "distinct (stage, helper) public inputs as in frozen caller proof", + "independent_adjoint": { + "E_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "45956159174072599700841582644791226032878246665742197512850210148957847086108563258880912378518411647758984921374583775627721903027855539985608524545788884385074028054962822941002911344421979827194338019317181669291086596879430115113578146646042105680303478329302401769326614809992435001600144772164326296955809382451/236574025616993083824920739000090624000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470618474927110629250565845181480463803853254183484427226999741924183858410142264176797069732759917922574584434237862536072382090671054557074313616044736234650520708908465285927889686274454991039162345983077755869741179076957394063036352251163125788931388495174547079429191/1135555322961566802359619547200434995200000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470618474927110629250565845181480463803853254183484427226999741924183858410142264176797069732759917922574584434237862536072382090671054557074313616044736234650520708908465285927889686274454991039162345983077755869740043521634432496233992631615925353936188495174547079429191/1135555322961566802359619547200434995200000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "45956159174072599700841582644791226032878246665742197512850210148957847086108563258880912378518411647758984921374583775627721903027855539985608524545788884385074028054962822941002911344421979827194338019317181669291086596879430115113578146646042105680303478329302401769326614809992435001600144772164326296955809382451/236574025616993083824920739000090624000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470618474927110629250565845181480463803853254183484427226999741924183858410142264176797069732759917922574584434237862536072382090671054557074313616044736234650520708908465285927889686274454991039162345983077755869741179076957394063036352251163125788931388495174547079429191/1135555322961566802359619547200434995200000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "5823402494196099305778791202540497872481412974099003478602150744965216125361362877323163160118830626877311440565020603416503076068985302561/43317997854674026579270154846208000000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "16693087639615725533916213296460681729045693942687345653799760274613091998620258371416256358174487989689829146031085677771966285652665171871880527619/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "215422193601072158775310616724805421780858470440047871957943352672685910373060620631520414662960783771331553012662796458561086773801434022508744256579381263/138617593134956885053664495507865600000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "765172019110513572981361159774534395205342222069661261195915979305234399594089996182081226412302639705606751485838705872296658860688795677410841935792394060546724711/924117287566379233691096636719104000000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "1373227143923868540124128978974178199272734458981546920039094283390125538591773800577672505034664739717096005718610376622532839509532565558416738477474980080213076175252276833/693087965674784425268322477539328000000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "20823385219253020417470968328846275074595710152007615526016316645460278451098840124053959352356282227411247858236200619860615576210319664507292497317603909895621506792749171012273075967/4435762980318620321717263856251699200000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "85942816230796790420859464298982165823243771253866559246709796609804449578582488412454053652624328287211038075245714649777527022652796078774265880147308561704971727755641315494949603413000289409/1848234575132758467382193273438208000000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "930254244993030761229829268847188896082982635829999215789606520209569897411716142061829400254128024059894883405179539103688271785187276107467990156277250036408928474781386035617384335491880084696565432881/11089407450796550804293159640629248000000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "26698235516885785065997401492429286765678723263541662410753084388444393193561800615125350923624653421767500425110167989575612328168376281681002817447260373370318893107280027285782741665466848975802248338503425718603465515390081629169609183332138433/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "333036985153880054482618557948835050810077718958836291192233820909862827605921776176864407048048718755574669223714977620002388350971257698279121263644529088056838950084380396846789882610902168941433756274426963595536868634552913487361112262100843350271705887/44357629803186203217172638562516992000000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "1485186443597101445216199568250063900555675940653280565893741147740873100643263302620321438750816724569332484673600125202834856306101875122184162314748431470308681935651470380653116086161506241046313293474684914183553186838203901059242439127633915903663802380930352247/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "159734677813645691152644956749584034015104198491772481767855753126142170164941002597233440049741346858902683018277267099835410568063596725465219321947056480273934495384256144981757048646713040722373079423612446916759348559547758589589452947800703238586431937868604993059023613/19714502134749423652076728250007552000000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "980153410758705132757296517408018064903725752900397383164884631190402779642318435399391212750748600794805336850064558326344288195528634443759279168419873035712489458831786252105077638554079527966462216057759339313223078916977275301812538686346116408319756021467053374646625836221541519/354861038425489625737381108500135936000000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "96723013183992897325904658155556017573071866746652119881535890368595309030395692319843863680510479710673150121644653820768807548418565836362799004539018427606753103480608572843162429398226531000101548548123891413851264615663102842065706726439746244692704905346817298847704565677366121651796817/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "47249676043683272948772425497268865397768579217032388089162395155531425970571393413393984258051103520107340631152474548668409197340126515100687150469726290297431241458334703391311001086756788363312603145838993193604154459060472299989325090825051741849732144722821136805949717853802544236165214437310743/1419444153701958502949524434000543744000000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "97572789564351095978680135899492248257695041017355671410934613040907430022279117685196487138264336307123681738305095296292919905561167381919488185243427693390142343561080260810561274563150882520233076883079377710914876030886741672661120664918424794883641185948943366509220259438929345696407591924372944301257/283888830740391700589904886800108748800000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "45956159174072599700841582644791226032878246665742197512850210148957847086108563258880912378518411647758984921374583775627721903027855539985608524545788884385074028054962822941002911344421979827194338019317181669291086596879430115113578146646042105680303478329302401769326614809992435001600144772164326296955809382451/236574025616993083824920739000090624000000000000000000000", + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "event": 4982, + "stage": 18 + } + ], + "physical_main_inputs": 3952, + "sites": { + "ADD": 4102, + "IDLE_ODD": 4, + "IDLE_ONE": 96, + "J": 18, + "LAMBDA": 214, + "QUERY": 4, + "SCALE": 298, + "SWAP": 376, + "noninteger_scalar": 1562 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 74627, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "strict_power_of_two": 269, + "witness": { + "cut": 73443, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 73443, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 74627, + "lifetimes": 56, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 64531, + "CLEAR": 56, + "COPY": 1, + "INIT": 56, + "MOVE": 6273, + "SCALE": 3710 + }, + "owned_labels": 53, + "peak_owned": 44, + "public": 1493, + "scalars": { + "dyadic": 62806, + "integer": 39362, + "noninteger": 28880, + "odd": 5436 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 15457466, + "dyadic_height": 25, + "mass_witness": [ + 65219, + "stored add" + ], + "maximum_scaled_mass": "814448574117075/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + } + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "11305693439320565196001396423420695012100353120477900458463497879018991678562289/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "5652846719660282598000698211710347506050176560238950229231748939509495848585909/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.00364235506642", + "gain": "5.45952726E-7", + "gain_exact": "272976363/500000000000000", + "independent_raw_bracket": [ + "0.00364235506642014122674740555295532", + "0.00364235506642014122674740555295533" + ], + "previous_claim": "1820904556847/500000000000000", + "raw_bracket": [ + "0.0036423550664201412267474055529553", + "0.0036423550664201412267474055529554" + ] + }, + "signed_routes": { + "ambient": 153, + "bindings": [ + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 17, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "old9_route": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 15, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 81, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 64, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 17, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "old9_route": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 15, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 81, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 63, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 19, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "old9_route": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 17, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 273, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 19, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "old9_route": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 17, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 273, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 67, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 30, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 2 + ], + [ + "XOR", + 0, + 2 + ], + [ + "SWAP", + 2, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 2, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 2, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "old9_route": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 27, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 262, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 61, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 30, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 2 + ], + [ + "XOR", + 0, + 2 + ], + [ + "SWAP", + 2, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 2, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 2, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "old9_route": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 27, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 262, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 55, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 38, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "old9_route": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 34, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 98, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 68, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 38, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "old9_route": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 34, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 98, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 40, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "old9_route": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 35, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 290, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 40, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "old9_route": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 35, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 290, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 62, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 47, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 2, + 3 + ], + [ + "XOR", + 0, + 3 + ], + [ + "SWAP", + 3, + 8 + ], + [ + "XOR", + 8, + 2 + ], + [ + "XOR", + 3, + 2 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 3, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "old9_route": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 42, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 268, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 62, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 47, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 2, + 3 + ], + [ + "XOR", + 0, + 3 + ], + [ + "SWAP", + 3, + 8 + ], + [ + "XOR", + 8, + 2 + ], + [ + "XOR", + 3, + 2 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 3, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "old9_route": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 42, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 268, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 52, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 7 + ], + [ + "XOR", + 0, + 7 + ], + [ + "XOR", + 2, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 7 + ], + [ + "XOR", + 7, + 2 + ], + [ + "XOR", + 5, + 2 + ], + [ + "XOR", + 7, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "old9_route": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 47, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 164, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 52, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 7 + ], + [ + "XOR", + 0, + 7 + ], + [ + "XOR", + 2, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 7 + ], + [ + "XOR", + 7, + 2 + ], + [ + "XOR", + 5, + 2 + ], + [ + "XOR", + 7, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "old9_route": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 47, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 164, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 59, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 60, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 3, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 3, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 3 + ], + [ + "XOR", + 4, + 3 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ], + [ + "SWAP", + 0, + 3 + ] + ], + "old9_inverse": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "old9_route": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 55, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 280, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 55, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 60, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 3, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 3, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 3 + ], + [ + "XOR", + 4, + 3 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ], + [ + "SWAP", + 0, + 3 + ] + ], + "old9_inverse": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "old9_route": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 55, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 280, + "stage": 10 + } + ], + "paid_calls": 32, + "proposed_sha": "9557f713ab4ffb91ede05e8a6d5668c694b9940fc16f2f2d657e2f2b2cac2d3f", + "status": "PASS_PHYSICAL_RANK9_ALGEBRA", + "word_sha": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea" + }, + "source_head": "666fd749ec465de7238633a0c2fd5ee3081477e0", + "status": "PASS_P104_CAUSAL_BUFFER_NATIVE", + "word_canonical_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea" +} diff --git a/research/p104-causal-buffer-split/NOTICE b/research/p104-causal-buffer-split/NOTICE new file mode 100644 index 0000000000..780b4f6e39 --- /dev/null +++ b/research/p104-causal-buffer-split/NOTICE @@ -0,0 +1,9 @@ +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. + +Ali Romman: causal-history owned-buffer split identity and helper bases. +Jerry Chen / CubeJerry: contact-free retiming, temporal history, independent native/caller, precision and compiler methods. +Matarener: complete helper kernels. Rohan Arun: input/output rechart, signed17-stage caller and application. +Cinna Davis / 1337isnot1337: alpha expansion. Dugongue: temporal S09 predecessor. +ToikY, DreamingOfClouds, Douglas Colkitt/#7000 reviewers and every author in the complete frozen source closure remain credited. + +The complete prior composition artifact666fd749 is retained, with its notices and all nested sources. Ali Romman causal-history discussion: https://github.com/CrocSwap/integer-mult-bounds/discussions/5600#discussioncomment-19209322 diff --git a/research/p104-causal-buffer-split/PATHS.json b/research/p104-causal-buffer-split/PATHS.json new file mode 100644 index 0000000000..c4e97f5b6f --- /dev/null +++ b/research/p104-causal-buffer-split/PATHS.json @@ -0,0 +1,93 @@ +[ + { + "role": 22, + "lo": 32782, + "hi": 45280, + "frame": 237, + "moves": [ + 45278 + ], + "frames": [ + 237, + 127 + ] + }, + { + "role": 23, + "lo": 27540, + "hi": 27553, + "frame": 237, + "moves": [ + 27552 + ], + "frames": [ + 380, + 237 + ] + }, + { + "role": 320, + "lo": 27429, + "hi": 27548, + "frame": 237, + "moves": [ + 27547 + ], + "frames": [ + 376, + 237 + ] + }, + { + "role": 321, + "lo": 27476, + "hi": 27546, + "frame": 237, + "moves": [ + 27545 + ], + "frames": [ + 378, + 237 + ] + }, + { + "role": 323, + "lo": 27366, + "hi": 27555, + "frame": 237, + "moves": [ + 27554 + ], + "frames": [ + 377, + 237 + ] + }, + { + "role": 330, + "lo": 27482, + "hi": 27562, + "frame": 237, + "moves": [ + 27561 + ], + "frames": [ + 379, + 237 + ] + }, + { + "role": 333, + "lo": 40066, + "hi": 44265, + "frame": 237, + "moves": [ + 44264 + ], + "frames": [ + 735, + 237 + ] + } +] diff --git a/research/p104-causal-buffer-split/PROOF.md b/research/p104-causal-buffer-split/PROOF.md new file mode 100644 index 0000000000..74745ea813 --- /dev/null +++ b/research/p104-causal-buffer-split/PROOF.md @@ -0,0 +1,140 @@ +# A timed two-buffer helper split on the exact composed word + +This is a source-bound conditional construction and finite certificate. It is +not a proof of the complete multiplication theorem. Ali Romman's causal-history +owned-buffer mechanism is the predecessor; this package supplies a newly priced +instance on the current word. CubeJerry's contact-free retiming and temporal +coefficient methods, Matarener's kernel methods, and all retained source authors +remain credited. + +## Source and typed observations + +The complete 37-file artifact at +`666fd749ec465de7238633a0c2fd5ee3081477e0`, +`research/p104-output-rechart-composition`, is retained in `INPUTS.json`. +Its reconstructed native SHA256 is +`9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a`. +Rohan Arun's PR #7131 represents the identical canonical native construction. +The selected frontier is not changed here. + +A cut t means immediately before original event t. Work in normalized chart +coordinates, in which a correctly implemented MOVE preserves scalar values. +Let P(t,r) be the complete source row at that cut and S(t,r) the complete final +response to adding one unit to role r there. Both include every public input or +output coordinate, with owned INIT/CLEAR and COPY treated explicitly. + +Take F=237 with basis [30,75,138,266], dimension four; U=3 is the zero space and +V=127 the full nine-dimensional space. The certificate gives + +| Cut | Role | Gather coefficient | +|---:|---:|---:| +|27366|323|−1| +|27429|320|−2| +|27476|321|1| +|27482|330|2| +|27540|23|2| +|40052|49|1| +|40066|333|−2| + +The exact sum of these rows is + +`c = −e411 − e320/2 − e331/2 − e335/2`. + +The sole later injection is role 22 at cut 45280 with coefficient −2. Its +complete response is `d = −2 e331`. Thus `c d = 1`. Every support coordinate +belongs to the helper boundary group (3,127); all main and other helper +coefficients cancel exactly. `certificate.py` reconstructs these equations +from the frozen source, without importing the search. + +Seven original MOVE paths are retimed within their adjacent scalar contacts, +as listed in `PATHS.json`. No target write or source read lies inside those +intervals. Their ordered paths and paid ranks are retained. The additional +path is role 49, interval [40052,47650], original event 47648: frame 734 to 127, +rank six. Frame 734 has basis [30,138,266]. Replace it by 734→237 at cut 40052 +and 237→127 at cut 47650, ranks one and five. All observations are performed +after entry to F and before departure. The constructor checks the literal +source intervals, all original scalar frames and the retiring pivot's actual +residency. Original MOVE indices are removed only after those checks. + +## Boundary identity and chronology + +Let p=333. The credited helper-basis algorithm emits G with row p equal to c +and `G d = e_p`. Its eight elementary instructions and their inverses use the +existing 2,3,5-smooth alphabet. Apply G inverse to the old helper inputs at U. +Then the timed gather functional c has value x_p, the original independent +input assigned to p. All main inputs and other boundary groups are untouched. + +Introduce a fresh independent public input z at F, role n=1492. It is an +arbitrary input, not an initialized scratch field. Explicitly initialize owned +A at F before the first gather and add the seven observations to it. Because +gathers only read the old program before retirement, A=x_p at cut 40066. + +At that cut p actually resides at F. Let its current value be v. Initialize +owned B=0 at F and emit: + +``` +B += n +B -= A +n += p +n -= A +n -= B +p += A +p -= n +``` + +Now B=z−x_p, n=v and p=x_p. Clear A explicitly under the inherited owned-erasure +assumption. Retire p at F; all remaining occurrences of old p use n instead. +Every old owned label is shifted by one to make room for the new public role. + +At cut 45280 emit `role22 += −2 B` in F. The response identity shows that this +changes the old final outputs by `d(z−x_p)`. Clear B after this injection. The +old circuit otherwise continues unchanged in normalized coordinates. +Finish with G at V, using n as the successor of p. Since the source acts as the +identity on the helper group and `G d=e_p`, all continuing outputs have their +original values except the successor p slot, which is z. The retired public p +already equals x_p. Every independent public input is therefore restored to +its specified output, and all main actions are preserved. + +This argument uses two explicit owned accumulators and their erasure contract. +It does not assume that the local replacement on public cut coordinates is +invertible or that a simultaneous middle pairing equals one. It does not add +an opcode or grant a free cross-frame exchange. The whole emitted operator is +also checked separately by exact forward and transposed reverse execution. + +## Complete change and obligations + +The productive helper ranks change by `{4:+1,5:+1,9:−1}`; paid MOVE ranks by +`{1:+1,5:+1,6:−1}`. Rank masses are unchanged. The native has 1,493 public +fields, 1,093 helpers, 53 owned labels, 56 owned lifetimes and exact owned peak +44. The previous counts were 1,492/1,092/51/54/43. Owned rise mass remains 56. +There are 74,627 events, a delta of 27 ADD, four SCALE, one MOVE, two INIT and +two CLEAR instructions. Both newly owned lifetimes and every scalar instruction +are included in ordinary, precision and finite-tape accounting. + +The 17-stage caller repeats the native changes 17 times: 110,417 paid positions, +22,325 productive fields, rank surplus 1,424 and zero empty credit. The two +directed price engines give claim κ=.003642959019031. Full application evidence +and verification status belong to `APPLICATION.md` and `VALIDATION.md`; this +algebraic argument alone does not discharge their obligations. + +The independently derived grid remains 1125/F25. Precision adapters replace +the old exact lifecycle census (54,43,51) by the checked new census (56,44,53), +with counted source substitutions in temporary code only. The lifecycle check +is retained, and an extra uncharged lifetime is rejected. Frozen predecessor +bytes are not edited. + +The five framework assumptions remain `native_all_columns`, `owned_erasure`, +`compiler`, `precision_tape` and `analytic_recovery`. Finite complete checks, +independent human/formal acceptance, maintainer admission and execution of a +compiled top-level multiplier are distinct obligations. + +## Open next questions + +1. Independently replay the timed coefficient certificate and complete + application, especially the two owned lifetimes and their compiler costs. +2. On a freshly pinned successor, can a different causal history repay its + complete path and storage bill? The search stopped at its first positive; + it does not prove a temporal ceiling or exhaust the remaining paths. + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. All nested source notices are retained. diff --git a/research/p104-causal-buffer-split/README.md b/research/p104-causal-buffer-split/README.md new file mode 100644 index 0000000000..39d808ae7d --- /dev/null +++ b/research/p104-causal-buffer-split/README.md @@ -0,0 +1,101 @@ +# Conditional κ = 0.003642959019031 from a causal-history buffer split + +This source-bound candidate improves the complete signed P104 invoice over +[#7131](https://github.com/CrocSwap/integer-mult-bounds/pull/7131) by +**0.000000550522162**, from κ=.003642408496869 to **κ=.003642959019031**. +All three direct CPython 3.14.7 checks passed. Final registered isolated Python +3.12.16 replay passed all three commands and matched every frozen receipt field. No admission or selected-frontier change is claimed. + +Seven values collected at different times in frame 237 isolate one helper +input after a boundary basis change. Two explicitly initialized owned buffers +permit that helper to retire at the intermediate frame while a fresh arbitrary +public input continues its old program. One later injection restores the full +output direction. One paid transport changes from rank six to ranks one and +five, funding a productive helper split from rank nine to ranks four and five. +This is an instance of **Ali Romman's causal-history owned-buffer mechanism**; +[PROOF.md](PROOF.md) states the exact source, chronology and identity. + +| Count | Source | Candidate | +|---|---:|---:| +|Native public fields|1492|1493| +|Native independent helpers|1092|1093| +|Owned labels|51|53| +|Owned lifetimes|54|56| +|Peak simultaneous owned fields|43|44| +|Native instructions|74591|74627| +|Complete paid positions|110400|110417| +|Complete productive fields|22308|22325| +|Rank surplus|1424|1424| +|Empty credit|0|0| + +The exact per-native changes are ΔP={1:+1,5:+1,6:−1} and +ΔT={4:+1,5:+1,9:−1}. Every added scalar, owned lifetime and compiler service is +charged in the application checks. The candidate has 27 more ADDs, four SCALEs, +one MOVE, two INITs and two CLEARs. The fresh minimal grid remains **1125/F25**. +The two directed price engines locate the emitted invoice's crossing in + +``` +(0.0036429590190313419414962272850934, + 0.0036429590190313419414962272850935). +``` + +This is an invoice-specific ceiling, not an optimum over temporal programs. +The retained BIT cap .00376669 leaves .000123730980969 headroom above the claim. +The original one-path search stopped at its first positive after 150 of 7,687 +individually affordable paths; it does not exclude the unvisited domain. + +## Exact inputs and reproduction + +`INPUTS.json` authenticates the complete 37-file independent composition artifact +at `666fd749ec465de7238633a0c2fd5ee3081477e0`, with every nested source and notice. +The construction is the same canonical native as Rohan Arun's completed #7131 +at `67a6544cf18b2d372fd1d0deee1863e9f6ca9fc5`. This package uses the fully retained +666fd artifact as its byte-exact predecessor; it does not claim to replay the +entire separate #7131 package. + +Source native SHA256: +`9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a`. +Candidate native SHA256: +`81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea`. +The signed 17-stage caller from Rohan Arun's #7113 remains byte-identical, +SHA256 `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`. + +```sh +git fetch --no-tags https://github.com/CrocSwap/integer-mult-bounds.git main +python3.12 -B scripts/research_package.py --package research/p104-causal-buffer-split +``` + +The hook checks the exact timed coefficient certificate, complete native and +complete caller application. It reconstructs the source, all observation times +and paths, arbitrary-input forward/adjoint, lifecycle census, grids/envelopes, +phase, physical ownership, all 3,039 paid/helper maps and 104 main boundaries, +ordinary and finite-tape work, both price engines and 54 strict plus four +functional outer conditions. Every frozen receipt field must match. +[VALIDATION.md](VALIDATION.md) records the actual completed commands and limits; +[APPLICATION.md](APPLICATION.md) records full-cost substitutions. + +## Scope and credit + +The five inherited assumptions remain `native_all_columns`, `owned_erasure`, +`compiler`, `precision_tape`, `analytic_recovery`. Independent human/formal +review, maintainer admission and compiled top-level execution remain open. +Finite verification is distinct from each of those obligations. + +Credit **Ali Romman** for causal-history buffers and helper bases; +**Jerry Chen/CubeJerry** for contact-free retiming, temporal coefficient and +native/caller/precision/compiler methods; **Matarener** for complete kernels; +**Rohan Arun** for input/output recharting and the shortened signed caller; +**Cinna Davis/1337isnot1337**, **Dugongue**, **ToikY**, **DreamingOfClouds**, +**Douglas Colkitt/#7000 reviewers** and every retained nested source author. +The dillona #7130 split and independent 666fd composition artifact are fully +retained. Prepared for dillona with substantial OpenAI Codex assistance; +no subagents. Apache-2.0. + +## Open next questions + +- Independently replay the exact causal certificate and complete application, + especially the additional owned lifetimes and precision/cost adapters. +- After refreshing upstream and overlap, test a distinct source-bound temporal + domain on the successor. This first-positive search establishes no ceiling. + +[Canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521). diff --git a/research/p104-causal-buffer-split/REPLAY.txt b/research/p104-causal-buffer-split/REPLAY.txt new file mode 100644 index 0000000000..89287f3c49 --- /dev/null +++ b/research/p104-causal-buffer-split/REPLAY.txt @@ -0,0 +1,75 @@ +CHECK Authenticate full37-file source and nested closure; reconstruct all seven timed prefix rows and one suffix column, unit boundary pairing, exact path chronology and entire candidate; reject ten temporal/cost corruptions and compare every certificate field. +PASS_EXACT_TIMED_OBSERVATIONS +CHECK Reconstruct full source/candidate; exact forward/adjoint, every owned lifecycle and full paid/productive delta; independent1125/F25 derivation; ingredient caller/price/ordinary/envelopes; phase and affected512-column maps, temporal/native/grid/owned controls and finite native/signed physical routes; every frozen receipt field. +PASS whole source/operator, forward/adjoint, causal charts and fresh native grid +caller 0 terms 77 +caller 500 terms 621 +caller 1000 terms 2648 +caller 1500 terms 3619 +caller 2000 terms 1590 +caller 2500 terms 398 +caller 3000 terms 1918 +caller 3500 terms 1797 +caller 4000 terms 1817 +caller 4500 terms 912 +caller 5000 terms 167 +PASS full ingredient invoice, ordinary, precision, both prices and outer gates +events 74627 public 1493 owned roles 53 paid {1: 3994, 2: 854, 3: 827, 4: 224, 5: 342, 6: 15, 7: 11, 8: 6} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 16, 2: 20, 3: 47, 4: 219, 5: 75, 6: 43, 7: 18, 8: 35, 9: 620} +endpoint bad rows 0 odd certificate S 1125 +PASS_HOST3 decoupled ports 96 hosted ports 8 +gate interpreter agrees with the library on 4 exact state vectors +replayed 74627 events, 2954 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1093), X rows bad 0, Y rows bad 0, X2 rows bad 0, Y2 rows bad 0 (of 104 ports; 96 with second mains) +tableau on 104 ports: XX!=D 0 YY!=D 0 YX!=Q^-1D 0 XY!=QD 0 | controls matching (must be 0): 0 0 +PASS_PHYSICAL 27s +PASS affected Gaussian chart columns, phase, corruption controls and finite physical replay +PASS_P104_CAUSAL_BUFFER_NATIVE 182117753321/50000000000000 +CHECK Full unchanged17-stage signed caller; all3039 paid/helper maps and104 main boundaries; fresh native/caller grid and envelopes, owned stock, ordinary/physical/fixed-tape work, both directed prices and54+4 outer conditions; every application receipt field. +PASS two reconstructed invoices and both exact price engines 0.003642959019031 +RUN emit_odd_type_b.py +caller 0 terms 41 +caller 500 terms 1178 +caller 1000 terms 2699 +caller 1500 terms 1262 +caller 2000 terms 881 +caller 2500 terms 2484 +caller 3000 terms 765 +caller 3500 terms 640 +caller 0 terms 41 +caller 500 terms 1178 +caller 1000 terms 2701 +caller 1500 terms 1264 +caller 2000 terms 881 +caller 2500 terms 2485 +caller 3000 terms 765 +caller 3500 terms 641 +PASS exact short type B 3877 events Counter({8: 34, 9: 4, 56: 4, 48: 4, 40: 4, 32: 4, 24: 4, 16: 4, 64: 2}) +RUN emit_odd_type_ab.py +caller 0 terms 73 +caller 500 terms 1076 +caller 1000 terms 2476 +caller 1500 terms 1334 +caller 2000 terms 2078 +caller 2500 terms 1235 +caller 3000 terms 2978 +caller 3500 terms 2335 +caller 4000 terms 1046 +caller 4500 terms 299 +PASS exact short A+B 4783 events 3752 ['18214795095156709707481136425467/5000000000000000000000000000000000', '7285918038062683882992454570187/2000000000000000000000000000000000'] +RUN check_odd_caller_exact_grid.py +PASS odd caller grid [381, 69, 62] [381, 3, 2] scale bits 10 checked 176874 +RUN check_odd_physical_binding.py +PASS exact physical binding 110417 13600 22325 +RUN check_odd_precision.py +PASS short precision 406 1181 2362 +RUN check_odd_partial_admission.py +ordinary bill 779064884 +PASS partial signed short gates 779064884 3642959019031/1000000000000000 {'strict_count': 54, 'functional_count': 4, 'minimum_margin': '1/1000000000000000000', 'BIT_just_below_effective_rejected': True} +RUN check_odd_fixed_tape_counts.py +PASS finite tariff substitution 42819968 25436979648 precision 2362 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3039 +PASS complete 8+9 component application checks 3642959019031/1000000000000000 3039 110417 +PASS_P104_CAUSAL_BUFFER_SPLIT 3642959019031/1000000000000000 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-causal-buffer-split outcome=partial diff --git a/research/p104-causal-buffer-split/RESULT.json b/research/p104-causal-buffer-split/RESULT.json new file mode 100644 index 0000000000..b7f91ee924 --- /dev/null +++ b/research/p104-causal-buffer-split/RESULT.json @@ -0,0 +1,1566 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "8954e7eca3613ff24cdb82417ab067488295600bde848f2416b761ba165dc94a", + "check_odd_precision.py": "92575d02396d293fd7c7be5be8d661affc9b3399acf2185298c485d7a695eb87", + "emit_odd_type_ab.py": "6fd9f61f9ba6c726524d1a585d0201b0eac61829ccae6be598f0f0fc1cb64f1a" + }, + "edits": [ + { + "file": "emit_odd_type_ab.py", + "new": "invoice=json.loads((root/\"COHORT-PRICE.json\").read_text())", + "old": "invoice=next(x for x in json.loads((root/\"SHORT-CALLER-RAW-PRICE.json\").read_text())[\"rows\"] if tuple(x[\"shape\"])==shape)" + }, + { + "file": "check_odd_partial_admission.py", + "new": "actual_native=ind.native(w)\nassert actual_native==N and not N[\"bad_inputs\"], \"Fresh complete native inventory and arbitrary-input adjoint\"", + "old": "previous=json.loads((root/\"SHORT-ADMISSION-PARTIAL.json\").read_text())\nassert previous[\"native_sha256\"]==digest and not N[\"bad_inputs\"]" + }, + { + "file": "check_odd_partial_admission.py", + "new": "claim=Q(\".003642959019031\")", + "old": "claim=Q(\".00363797977\")" + }, + { + "file": "check_odd_partial_admission.py", + "new": "tested=claim+Q(7,10**17)\nwhile tested>=Q(reference[\"raw_bracket\"][0]):\n tested=claim+(tested-claim)/10", + "old": "tested=claim+Q(7,10**17)" + }, + { + "file": "check_odd_partial_admission.py", + "new": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])\ntry:\n gate(invoice,claim,Q(bracket[0]),*bracket,r[\"gate\"][\"BIT_pin\"])\nexcept AssertionError:\n crossing_probe_rejected=True\nelse:\n raise AssertionError(\"Probe at lower crossing unexpectedly accepted\")", + "old": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])" + }, + { + "file": "check_odd_partial_admission.py", + "new": "\"crossing_probe_rejected\":crossing_probe_rejected,\"scope\":\"Reuse exact same native word all-column adjoint;", + "old": "\"scope\":\"Reuse exact same native word all-column adjoint;" + }, + { + "file": "check_odd_precision.py", + "new": "patch('(life, peak, owned_count) == (54, 43, 51)','(life, peak, owned_count) == (56, 44, 53)')\nenv=ModuleType(\"short_envelope\")", + "old": "env=ModuleType(\"short_envelope\")" + }, + { + "file": "check_odd_precision.py", + "new": "", + "old": "previous=json.loads((root/\"SHORT-PRECISION.json\").read_text())" + }, + { + "file": "check_odd_precision.py", + "new": "assert grid_receipt[\"caller_sha256\"]==sha256(cpath.read_bytes()).hexdigest()", + "old": "assert previous[\"native_sha256\"]==sha and grid_receipt[\"caller_sha256\"]==sha256(cpath.read_bytes()).hexdigest()" + }, + { + "file": "check_odd_precision.py", + "new": "wg=grid.word_run(w, frac=25)\nwp,wr=env.native_envelope(w)\nwg=json.loads(json.dumps(wg,default=str));wr=json.loads(json.dumps(wr,default=str))\nassert wg==r[\"precision\"][\"word\"] and wr==r[\"precision\"][\"rounded_native\"], \"Fresh changed-native grid and envelope\"", + "old": "wg=previous[\"native_grid\"]\nwr=previous[\"rounded_native\"]\nwp={key:(Q(v[\"exact\"]),v[\"witness\"]) for key,v in wr[\"bounds\"].items()}" + } + ] + }, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "catalogue": [ + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "b9cdcbe051edca0b1fb57ede0bc0ba3c8614a4586d18b8946141fc9030ca731e", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 0, + "slice_stop": 1000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + }, + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "3e70bf7c9c05d1194c607367fe8e874627d3e2a4ac5a995454b53232f6466859", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 1000, + "slice_stop": 2000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + }, + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1039, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "13c902444c5ee767f6655cfdb891f8c9efb41f2cbb3f735b31076a63dcec361e", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3039, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "3642959019031/1000000000000000", + "catalogue": [ + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "b9cdcbe051edca0b1fb57ede0bc0ba3c8614a4586d18b8946141fc9030ca731e", + "log_sha256": "ab793ad1c0587b6f3ac2193601af8141917ba9d40ae1fec76aad5dba5700385c", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 0, + "slice_stop": 1000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + }, + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "3e70bf7c9c05d1194c607367fe8e874627d3e2a4ac5a995454b53232f6466859", + "log_sha256": "c887cd84447cc8995fb0253495d51da5892f46fcbf7435d4f20c5abba56f75f7", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 1000, + "slice_stop": 2000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + }, + { + "catalogue_digest": "69298978f6127e4606fe7a5784851f42b716b8f799fe9aa892effb1e6b494a87", + "catalogue_size": 3039, + "checked_maps": 1039, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2954, + "exact_recipe_digest": "13c902444c5ee767f6655cfdb891f8c9efb41f2cbb3f735b31076a63dcec361e", + "log_sha256": "b751532f4d8b7a1929c3c638acb88d5be7655026846b2c7442d08cb1f372b993", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3039, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b" + } + ], + "fixed_tape_counts": { + "H": 16502900000000000000000, + "Kstar_bits": 14093, + "actual_ambient": 145, + "caller_odd_scale": 675, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "common_grid": { + "fractional": "p+D", + "signed_width": "p+h+2D+3", + "temp_padding": 26 + }, + "compiler_ambient_cap": 153, + "context_bound_bits": 14104, + "context_c": 2362, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25436979648, + "log_power": 2236, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298332, + "native_invocations": 17, + "native_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "owned_banks_per_raw_occurrence": 901, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58250, + "native": 1162018 + }, + "scalar_services_upper": 42819968, + "scalar_steps_coefficient": 44899990765568, + "scope": "Exact finite-cost and common-format substitutions in the selected #7000 conditional application proof, using the conservative primitive movement and scalar constants there. The premise is the complete signed native/physical binding and retained compiler, BIT, stock, and outer contracts. This script counts the raw occurrence, not an enumerated top-level compiled multiplier.", + "tested_claim": "3642959019031/1000000000000000" + }, + "native_archive_sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b", + "native_canonical_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "numeric_gate": { + "BIT_margin": "12373098096893/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3642959019031/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9026528817657501, + 0.9026528817657501 + ], + "derivative_upper": -381892.2423110747, + "gamma": [ + 0.9408797743753462, + 0.9408797743753462 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3642959019031/1000000000000000": [ + "124293088663663442518716258647135014147791219614864987472804566256074644914603/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124293088663663442518716258647135014147791219614864987472804566256074644916561/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "15536636082958216123595817576854445570104906854663660196168242836993674806743/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "62146544331832864494383270307417782280419627418654640784672971347974699227939/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + 1.2354665789995948e-29, + 1.2354665789995948e-29 + ], + "364295901903107/100000000000000000": [ + 1.0550539201486245e-10, + 1.0550539201486245e-10 + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + -2.644242603988881e-29, + -2.644242603988881e-29 + ] + }, + "moment_margins": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + "123546657899959486461092598404716508942704788534721/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1235466578999594864610925984047165089427047923880701/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "10550539201486245811370790323921442081585515947798870272167289725983489/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10550539201486245811370790323921442081585515947798870272167289764715077/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + "-20658145343663134243269086297760667793158877677771/781250000000000000000000000000000000000000000000000000000000000000000000000000", + "-2644242603988881183138443046113365477524336303917627/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18214795095156709707481136425467/5000000000000000000000000000000000", + "7285918038062683882992454570187/2000000000000000000000000000000000" + ], + "tested": "364295901903107/100000000000000000", + "written_log_power": 2236 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "c79d05f20904051d1b108124f90051bdc2809fe8e419c2655b81a4049dbb32f6", + "fresh_helpers": 18581, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1493, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "paid_positions": 110417, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22325, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 901, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1275, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10956 + } + }, + "scope": "Conditional component application to the exact 8+9 source with the selected completed BIT predecessor and inherited five assumptions. Checks every normalized endpoint, every paid/helper nested chart map up to exact signed Pauli and absolute phase, caller occurrence/phase, precision, finite scalar and route bounds, and numeric gates. Does not run a compiled Turing machine, select an upstream frontier, or claim human/formal review.", + "source_unit_ordinary": { + "all_caller_scalar_surcharge": 2248928, + "caller_items": { + "A": { + "envelope": 102076416, + "field_boundary": 89856, + "fused_routes": 0, + "idle_routes": 170112000, + "output_routes": 213120000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 35730432, + "field_boundary": 7488, + "fused_routes": 1168000, + "idle_routes": 18016000, + "output_routes": 17760000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 559238336, + "charged_caller_odd_conversions": 479232, + "conservative_total": 779064884, + "init_clear_allowance": 224, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 220935116, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2639624, + "raw_upper": 762417100, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2186, + "moves": 6273, + "owned_lifetime": 224, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9883000, + "scalar_upper": 2068692 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12373098096893/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3642959019031/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9026528817657501, + 0.9026528817657501 + ], + "derivative_upper": -381892.2423110747, + "gamma": [ + 0.9408797743753462, + 0.9408797743753462 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3642959019031/1000000000000000": [ + "124293088663663442518716258647135014147791219614864987472804566256074644914603/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124293088663663442518716258647135014147791219614864987472804566256074644916561/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "15536636082958216123595817576854445570104906854663660196168242836993674806743/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "62146544331832864494383270307417782280419627418654640784672971347974699227939/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + 1.2354665789995948e-29, + 1.2354665789995948e-29 + ], + "364295901903107/100000000000000000": [ + 1.0550539201486245e-10, + 1.0550539201486245e-10 + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + -2.644242603988881e-29, + -2.644242603988881e-29 + ] + }, + "moment_margins": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + "123546657899959486461092598404716508942704788534721/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1235466578999594864610925984047165089427047923880701/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "10550539201486245811370790323921442081585515947798870272167289725983489/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10550539201486245811370790323921442081585515947798870272167289764715077/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + "-20658145343663134243269086297760667793158877677771/781250000000000000000000000000000000000000000000000000000000000000000000000000", + "-2644242603988881183138443046113365477524336303917627/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18214795095156709707481136425467/5000000000000000000000000000000000", + "7285918038062683882992454570187/2000000000000000000000000000000000" + ], + "tested": "364295901903107/100000000000000000", + "written_log_power": 2236 + }, + "crossing_probe_rejected": true, + "finite_rank9_fields": [ + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 3 + }, + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 3 + } + ], + "invoice": { + "P": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1275, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10956 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036429590190313419414962272850934318443089604962431425128023661325", + "raw_crossing": "0.0036429590190313419414962272850934318443089604962431425128023661325" + }, + "native_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "ordinary": { + "all_caller_scalar_surcharge": 2248928, + "caller_items": { + "A": { + "envelope": 102076416, + "field_boundary": 89856, + "fused_routes": 0, + "idle_routes": 170112000, + "output_routes": 213120000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 35730432, + "field_boundary": 7488, + "fused_routes": 1168000, + "idle_routes": 18016000, + "output_routes": 17760000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 559238336, + "charged_caller_odd_conversions": 479232, + "conservative_total": 779064884, + "init_clear_allowance": 224, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 220935116, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2639624, + "raw_upper": 762417100, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2186, + "moves": 6273, + "owned_lifetime": 224, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9883000, + "scalar_upper": 2068692 + }, + "scope": "Reuse exact same native word all-column adjoint; fresh exact signed caller and invoice, ordinary source-unit upper bill, inherited numerical compiler and outer inequalities, and signed rank9 child finite field routes. Fresh integrated physical native/caller and changed-word precision/occurrence application remain separate." + }, + "ODD-CALLER-EXACT-GRID.json": { + "caller_odd_scale": "675", + "caller_odd_scale_bits": 10, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "grid_exponents": [ + 381, + 3, + 2 + ], + "peak_terms": 3752, + "preproduct_exact_divisions": 176874, + "prime_order": [ + 2, + 3, + 5 + ], + "safe_valuation_bound": [ + 381, + 69, + 62 + ], + "scope": "Independent integer Laurent caller endpoint and pre-product divisibility. Valuation bound propagates complete field operators whose Gaussian coefficients have only power-of-two denominators, so odd factors are sourced only from the charged scalar operations. Fixed conversion and storage bounds still needed." + }, + "ODD-FIXED-TAPE-COUNTS.json": { + "H": 16502900000000000000000, + "Kstar_bits": 14093, + "actual_ambient": 145, + "caller_odd_scale": 675, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "common_grid": { + "fractional": "p+D", + "signed_width": "p+h+2D+3", + "temp_padding": 26 + }, + "compiler_ambient_cap": 153, + "context_bound_bits": 14104, + "context_c": 2362, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25436979648, + "log_power": 2236, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298332, + "native_invocations": 17, + "native_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "owned_banks_per_raw_occurrence": 901, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58250, + "native": 1162018 + }, + "scalar_services_upper": 42819968, + "scalar_steps_coefficient": 44899990765568, + "scope": "Exact finite-cost and common-format substitutions in the selected #7000 conditional application proof, using the conservative primitive movement and scalar constants there. The premise is the complete signed native/physical binding and retained compiler, BIT, stock, and outer contracts. This script counts the raw occurrence, not an enumerated top-level compiled multiplier.", + "tested_claim": "3642959019031/1000000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "c79d05f20904051d1b108124f90051bdc2809fe8e419c2655b81a4049dbb32f6", + "fresh_helpers": 18581, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1493, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "paid_positions": 110417, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22325, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 901, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1275, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10956 + } + }, + "patched_application_sha256": "733b31b1cee4567b466fdf834a34460b530f1f87ca6dca9270c0fabb2cf89849", + "scope": "Current caller port and ownership substitution, full phase-polynomial native contact identities on disjoint stage axes, whole signed idle/output geometry, and ordered paid positions. Retains the standard nested chart and local operator premises and requires separate full native replay and complete fixed-tape tariff application.", + "source_reviewer_sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184" + }, + "ODD-PRECISION.json": { + "caller_grid": { + "caller_odd_scale": "675", + "caller_odd_scale_bits": 10, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "grid_exponents": [ + 381, + 3, + 2 + ], + "peak_terms": 3752, + "preproduct_exact_divisions": 176874, + "prime_order": [ + 2, + 3, + 5 + ], + "safe_valuation_bound": [ + 381, + 69, + 62 + ], + "scope": "Independent integer Laurent caller endpoint and pre-product divisibility. Valuation bound propagates complete field operators whose Gaussian coefficients have only power-of-two denominators, so odd factors are sourced only from the charged scalar operations. Fixed conversion and storage bounds still needed." + }, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "context_c": 2362, + "context_height": 406, + "context_mass_bits": 1181, + "native_grid": { + "coefficient_visits": 15457466, + "dyadic_height": 25, + "mass_witness": [ + 65219, + "stored add" + ], + "maximum_scaled_mass": "814448574117075/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "precision_program_sha256": "93d2fee8fd23f1798a048d923f87f57c8a09a66f5baadc5b95f850c7b86add34", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "5950784623182845790996176145840141972606356023840973370249521817043291380770438575779765358055208679206393820260257964543157203199495567247565283729788615615330660486020131611610571067804274179261304176934069810994516635550419398545548494667442595825781142984192208470786117164932819477656515480112605189229132680253844505686669558029583605795279801518656826725935814233112204884000054952562609983813312121278413856365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "strict_power_of_two": 1148, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "153575481938414420628508914501089416303551490872808121299132771421995660309183487381336326318192908506014009470920229040590415061946563054081979589513306416983184023026239469568841975237926286224456503316628618409659349130646871831812793334125255835578626588333373551518393694381649294980097782214828217816490287618438653044273503700287509348594269954186389835671166828619619380718515210995989587282684635640982246546372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1153, + "witness": { + "cut": 4783, + "factor": "1", + "kind": "public-return", + "register": 37 + } + }, + "M_caller": { + "exact": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "strict_power_of_two": 897, + "witness": { + "cut": 4751, + "event": 4750, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "M_context": { + "exact": "24898013888919993652584785597659118414888760225153898690681323353849548691430846189546571328113953327115929439747538292251822531136700373054514250857682804946308296186288833087229230208019312190961037764911130623849647073737072448091925618670390169078788057051737711856255146547473379055095054976269385873641977866250839061650331870882547315770792311450900521569540674337375955954665609662715119285822786271811109183736515659129237/1686105475919371535105999294064230400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1160, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + }, + "M_joint_entrance": { + "exact": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "strict_power_of_two": 892, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Sigma_caller": { + "exact": "153575481938414420628508914501089416303551490872808121299132771421995660309183487381336326318192908506014009470920229040590415061946563054081979589513306416983184023026239469568841975237926286224456503316628618409659349130646871831812793334125255835578626588333373551518393694381649294980097782214828217816490287618438653044273503700287509348594269954186389835671166828619619380718515210995989587282684635640982246546372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1153, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "11903953213183887847459385683495444358909773259301407136752780222662134369652821010189930317546088174611441486140777162754821779784888010898027924303552067240518089688016795231964831268686383353052942410326649464851424101092331197931870790456028095250484260677215682360818118002562823600352922806567820175639881535626137238434275405194628196450013480771332800422015635128098861267025129110902349408730751765725507699654405081362387832693985299706365935714639223396627821058466189646261549296172565678452309705871141371182445438754741662606534456164976738030646009/7011716485308428615133405458301579549733503737764404511774644319027200000000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1416, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18581, + "helper_allocation_premise": "distinct (stage, helper) public inputs as in frozen caller proof", + "independent_adjoint": { + "E_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "5950784623182845790996176145840141972606356023840973370249521817043291380770438575779765358055208679206393820260257964543157203199495567247565283729788615615330660486020131611610571067804274179261304176934069810994516635550419398545548494667442595825781142984192208470786117164932819477656515480112605189229132680253844505686669558029583605795279801518656826725935814233112204884000054952562609983813312121278413856365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808121299132771421995660309183487381336326318192908506014009470920229040590415061946563054081979589513306416983184023026239469568841975237926286224456503316628618409659349130646871831812793334125255835578626588333373551518393694381649294980097782214828217816490287618438653044273503700287509348594269954186389835671166828619619380718515210995989587282684635640982246546372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808121299132771421995660309183487381336326318192908506014009470920229040590415061946563054081979589513306416983184023026239469568841975237926286224456503316628618409659349130646871831812793334125255835578626588333373551518393694381649294980097782214828217816490287618438653044273503700287509348594268057317729426378189834370413558459315210995989587282684635640982246546372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "5950784623182845790996176145840141972606356023840973370249521817043291380770438575779765358055208679206393820260257964543157203199495567247565283729788615615330660486020131611610571067804274179261304176934069810994516635550419398545548494667442595825781142984192208470786117164932819477656515480112605189229132680253844505686669558029583605795279801518656826725935814233112204884000054952562609983813312121278413856365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808121299132771421995660309183487381336326318192908506014009470920229040590415061946563054081979589513306416983184023026239469568841975237926286224456503316628618409659349130646871831812793334125255835578626588333373551518393694381649294980097782214828217816490287618438653044273503700287509348594269954186389835671166828619619380718515210995989587282684635640982246546372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "70781794236287195030348250068208882768064586700726624626896143320521689054548495631312275087363298244183130051280021224662344149834337395117/54147497318342533224087693557760000000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "107545294043015029201756409382013557124342398052652004760285878380714758216394879898111673788711420452216057333814860718611169230574360318948878033745197/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "100168175869035538583454700175395892596545528809091201361608979591175032885202425911706063089834825931723961091651515581274974958572090559993182471563265911827821/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "20462096215773093331938345895919888649659971619199078572871229492483745623327961022195349484065075457772180328965156343989729371326879727327020628079663213725518833792976891/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "1959245396486567172679556992644997486924117030619312241772585114038015020827198162640311819524458348022811160643253249083902534471375155129483822874168450971850098852872543604179477119/77972396138413247842686278723174400000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "208963523432934541384374238529763317306985995543555600225362289265291538614279433969950444636560419560383573367424395646585152050084366474413587339602241157816997199093153497933045882849501969969/8663599570934805315854030969241600000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "60841691818156516717396102157656697660676542114685476350507775054592209469679602090901581988050516712827066469363221096702066181463250935639731518427809231022020521969650311759590153916602926224040990667544673351/9746549517301655980335784840396800000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "21697531926071343710752970255685586859141744555390347739300872035989205160970987779188045628650448619504397521363607247259103589549894431866180127282710474288712633644569281989079711009214469085023145324279788118077574254312926814046610293437005242215965064773706787527668604444845356950108245783138214169375937259455426398372638687672422444335971/11240703172795810234039995293761536000000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "8250516653555791125890881867522338849450120456649649352755341289431044677880565331108421815808608311196727276778084905711672412267557306783567492272116628659394215357145711134397493976196513573611885202918431616183646934442072448334698235563526233442451938647207153452461983694778648037347999992488254663553537545514851701773561582826418712697210701382745847409/281017579319895255850999882344038400000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "3936204376350553959586383346644828166594520899380425887909711267823641432847437197238846637938619086892956784767127753390926228750011841613014115538417136275137786645675993232518012081261350368635710041356462012849645967262439101153435626992690109785252695342588038758010391060260755787588950212633863908201218213887659452534633657433315000042496192734409129295998821374571/9367252643996508528366662744801280000000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "49463970025121248366518699401031308310261171873816341123696833200501598550510479524468080478445575018597852810609738031368765417138701226986092769369616081103270804762679117090132042410899906066564709114518043386131490199377419309653570770840804171990206960173866331865520555299767260804752331887768941976808557227572513517335147229924235588197391576848867276689605530094151551426123467/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "3258160231781066034828529159079569045220708622411987917450310878618830485992764102499989418092715931646975563070030704150150377890382988392599839523463075040838638754263245503547541757980346745888895863142805487775723358806526657615753215233753470560957998010842669342092746784922979491070525807983315089506057656938684351044510710817251259261621792722657205022789668458189828406957453994867723/316144776734882162832374867637043200000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "130852841430007986947925306965587083830118455280870995521316782293868634351174067768275171057632598829119011705607637656105821225549934878495921257011327968261776492939515982596546615035218280240742454196398285961793881049136808155544028276040399974908983808523836368807633515702072422744713453828917018495046638999321063441118500630579725089064555320712223983557955298115541937120532804405066103783365187/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "2500880907037703392526195614784754002174462781117035670090278418229043323253893366663945573792660811495846786169435800342173626580474268497914964435982637978950524609983469982584854484350454420027496583172409524370018460010915544049239788695009441536137400200093516760407998257960668904738722014238956908402601917535772483113901869294686096757426085639400945641104939636022178130025689318484228745511628434702977/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "2768451246231694624969698856577357156018386083041525976037795296327244025642177024431376992830059396083782552586732241532475150644253223414350057378835690232943327502022558262411302134659955651335503244231767487939554273828982999912214837603021519112367326266347861194814012423700008146421621586151575090973011934626134570032618452386312938414186779986879709443582153174209891747131555685224621081558492599461222764040091/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "5950784623182845790996176145840141972606356023840973370249521817043291380770438575779765358055208679206393820260257964543157203199495567247565283729788615615330660486020131611610571067804274179261304176934069810994516635550419398545548494667442595825781142984192208470786117164932819477656515480112605189229132680253844505686669558029583605795279801518656826725935814233112204884000054952562609983813312121278413856365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "event": 4691, + "stage": 17 + } + ], + "physical_main_inputs": 3744, + "sites": { + "ADD": 4126, + "IDLE_ODD": 4, + "IDLE_ONE": 90, + "J": 17, + "LAMBDA": 178, + "QUERY": 4, + "SCALE": 312, + "SWAP": 52, + "noninteger_scalar": 1752 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 74627, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "strict_power_of_two": 269, + "witness": { + "cut": 73443, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 73443, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 74627, + "lifetimes": 56, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 64531, + "CLEAR": 56, + "COPY": 1, + "INIT": 56, + "MOVE": 6273, + "SCALE": 3710 + }, + "owned_labels": 53, + "peak_owned": 44, + "public": 1493, + "scalars": { + "dyadic": 62806, + "integer": 39362, + "noninteger": 28880, + "odd": 5436 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26502, + "entrance_mass": "2000400613863407002842941691911808177860173267989115067413570971414520160589774149438185177520635170102087981386777049177188649130175147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900521349683278266045136258945126791212940219592086862355317344005969116753251065102531/173271991418696106317080619384832000000000000000000000" + } + } + }, + "scope": "Fixed integer Laurent grid with charged odd caller scale, and pinned attributed forward/adjoint all-fibre defect engine applied to the emitted 17-stage caller. Each LAMBDA, QUERY and signed/unsigned idle is one unitary with one child defect. The caller allocation assumes independent stage helpers. Full physical application remains separate." + }, + "ODD-TYPE-AB-REPLAY.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "paid": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "raw_bracket": [ + "18214795095156709707481136425467/5000000000000000000000000000000000", + "7285918038062683882992454570187/2000000000000000000000000000000000" + ], + "replay": { + "bad_outputs": [], + "caller_denominator_height_bound": 578, + "caller_mass_bound": "854474036861847560509026474008040300059938928517783661039773198072080884690114508581583887358835968277340425788985297793555303569703690223623950838857161290503004459697662544865276977234864184443860251086668962688762176068520364648820282528496698239206689277049335412289161443623602012468587331439851515703/168151253906250000000000000000000", + "caller_mass_ceiling_bits": 910, + "max_terms": 3752 + }, + "scope": "Exact emitted signed Laurent caller endpoint and recomputed native/caller paid and target profiles. Physical address bindings, independent branch-source composition, ordinary units, precision and outer gates are still required.", + "shape": [ + 8, + 9 + ], + "source_word_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "target": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1275, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10956 + } + } + }, + "claim": "3642959019031/1000000000000000", + "price": { + "after": { + "P": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1275, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10956 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036429590190313419414962272850934318443089604962431425128023661325", + "raw_crossing": "0.0036429590190313419414962272850934318443089604962431425128023661325" + }, + "before": { + "P": { + "1": 68265, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5797, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3706, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10973 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036424084968693169933964196366183386853498606175933205372534926496", + "raw_crossing": "0.0036424084968693169933964196366183386853498606175933205372534926496" + }, + "gate": { + "BIT_margin": "12373098096893/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3642959019031/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9026528817657501, + 0.9026528817657501 + ], + "derivative_upper": -381892.2423110747, + "gamma": [ + 0.9408797743753462, + 0.9408797743753462 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3642959019031/1000000000000000": [ + "124293088663663442518716258647135014147791219614864987472804566256074644914603/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124293088663663442518716258647135014147791219614864987472804566256074644916561/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "15536636082958216123595817576854445570104906854663660196168242836993674806743/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "62146544331832864494383270307417782280419627418654640784672971347974699227939/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + 1.2354665789995948e-29, + 1.2354665789995948e-29 + ], + "364295901903107/100000000000000000": [ + 1.0550539201486245e-10, + 1.0550539201486245e-10 + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + -2.644242603988881e-29, + -2.644242603988881e-29 + ] + }, + "moment_margins": { + "18214795095156709707481136425467/5000000000000000000000000000000000": [ + "123546657899959486461092598404716508942704788534721/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1235466578999594864610925984047165089427047923880701/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364295901903107/100000000000000000": [ + "10550539201486245811370790323921442081585515947798870272167289725983489/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "10550539201486245811370790323921442081585515947798870272167289764715077/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7285918038062683882992454570187/2000000000000000000000000000000000": [ + "-20658145343663134243269086297760667793158877677771/781250000000000000000000000000000000000000000000000000000000000000000000000000", + "-2644242603988881183138443046113365477524336303917627/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18214795095156709707481136425467/5000000000000000000000000000000000", + "7285918038062683882992454570187/2000000000000000000000000000000000" + ], + "tested": "364295901903107/100000000000000000", + "written_log_power": 2236 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "old_native": "9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "5339670761576409060771607473019909128092781624078833934558815200515034201647553/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "21358683046305636243086429892079636512371126496315335738235260802060136841559473/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003642959019031", + "gain": "5.50522162E-7", + "gain_exact": "275261081/500000000000000", + "independent_raw_bracket": [ + "0.00364295901903134194149622728509343", + "0.00364295901903134194149622728509344" + ], + "previous_claim": "3642408496869/1000000000000000", + "raw_bracket": [ + "0.0036429590190313419414962272850934", + "0.0036429590190313419414962272850935" + ] + } + }, + "status": "PASS_P104_CAUSAL_BUFFER_SPLIT" +} diff --git a/research/p104-causal-buffer-split/SOURCES.json b/research/p104-causal-buffer-split/SOURCES.json new file mode 100644 index 0000000000..c4150ae397 --- /dev/null +++ b/research/p104-causal-buffer-split/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + } + ] +} diff --git a/research/p104-causal-buffer-split/TASK.json b/research/p104-causal-buffer-split/TASK.json new file mode 100644 index 0000000000..69188d722f --- /dev/null +++ b/research/p104-causal-buffer-split/TASK.json @@ -0,0 +1,153 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "author": "Prepared for dillona with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521", + "scope_status": "changed", + "scope_change_reason": "Replace simultaneous-cut bases with Ali Romman causal-history buffers on the exact completed composition. One paid midpoint plus seven neutral paths permits timed helper collection and delivery; all additional owned/scalar costs must be verified.", + "concrete_question": "Can one paid rank-six midpoint fund a causal rank-nine helper split with two explicitly charged owned buffers?", + "actual_scope": "Frame237/cut40066/pivot333 on exact666fd749 word9557; seven gathers, one injection; two owned accumulators; entire native and signed17-stage application. No selected-frontier change.", + "domain": "One source-pinned timed certificate and deterministic constructor. Discovery stopped at first positive, after150 of7687 individually affordable paths; no exhaustive optimality claim.", + "success": "A fully checked changed paid/productive invoice with kappa > .003642408496869.", + "bottleneck_link": "Temporal gathering makes the needed helper boundary functional available using one charged path; explicit storage and later delivery must not repay the gain.", + "predecessor_head": "666fd749ec465de7238633a0c2fd5ee3081477e0", + "predecessors": [ + "Ali Romman: explicit causal-history two-buffer identity and allowance for singular local replacement under owned erasure; Discussion5600/comment19209322.", + "Jerry Chen/CubeJerry: contact-free retiming, temporal pure spaces, exact native/caller, precision/compiler and cost engines.", + "Matarener: complete helper-kernel methods.", + "dillona/OpenAI Codex: exact37-file666fd749 composition artifact retained as full frozen input; completed independent artifact for identical Rohan Arun PR7131 canonical native.", + "Rohan Arun: #7124 output rechart, #7122 input rechart and #7113 signed17-stage caller.", + "Cinna Davis/1337isnot1337: alpha-expansion rechart predecessor; Dugongue: temporal S09 predecessor.", + "dillona/OpenAI Codex #7130 nonunit-pivot split, exact161e482bc2d8c78ecef96135430c60d49b8fc345, complete25-file export with full nested #7123 closure retained.", + "Rohan Arun #7124 output rechart, exact97dc14132da53562b7939776d7a83d72af72eeb1; byte-identical constructor and original specification retained among eight pinned peer files. 1337isnot1337/OpenAI Codex supplied alpha expansion. This package transfers their nominated changes to #7130, without claiming a new rechart search.", + "dillona/OpenAI Codex #7123 exact 020d581d9856b6db83e448c3f20418bc63b72c34, retained complete 30-file export and all nested sources. #7112 zero-pivot smooth swap is extended here to a nonzero nonunit pivot.", + "Rohan Arun7122 global input rechart, exact98aad9eb0e7d7f985622a35c7981695fe680c68a, retained as complete9-fileexport with nested7121closure; draft native/price evidence at this frozen head.", + "1337isnot1337/OpenAI Codex fresh-helper-boundary/discover-cut.cpp alpha-expansion method used by Rohan Arun7122; later completed source6391d64 retains identical six construction/source files, recorded in PEER-STATUS.json.", + "ToikY Discussion7111 original chart120 pattern, retained through7120; it is retained through the exact predecessor chain.", + "Ali Romman: helper bases, independent split identity and paid meetings", + "Jerry Chen/CubeJerry: causal retiming, native/invoice/compiler engines", + "Matarener: complete kernels including zero boundary images and pairing decision", + "Rohan Arun: exact7113 signed17-stage caller and source-specific application", + "ToikY: #7108\u2013#7110 signed sources and splits, plus the credited chart-120 lead in Discussion #7111", + "DreamingOfClouds, Douglas Colkitt/#7000 reviewers and all retained nested-source notices", + "dillona/OpenAI Codex:7105,7107,7112,7115,7116,7117; exact7117 parent retains all earlier exports", + "dillona/OpenAI Codex7118: first funded residual mode and exact source-specific application", + "dillona/OpenAI Codex7119: exact reciprocal source and full application", + "ToikY original chart120 pattern and dillona/OpenAI Codex7120 exact-source composition, fully retained as the immediate source." + ], + "outcome": "completed", + "evidence_status": "All three direct CPython 3.14.7 commands and final registered isolated CPython 3.12.16 replay passed. Every frozen certificate/native/application receipt field matched; 23 scientific hashes stayed unchanged. Ten certificate and 18 native controls, five 512-column rechecks, all 3039 paid/helper maps and 104 main boundaries, full costs and 54+4 outer conditions.", + "evidence": "WITNESS.json,PATHS.json,CERTIFICATE.json,WORD.json.gz,INPUTS.json,NATIVE-RESULT.json,RESULT.json,REPLAY.txt when complete.", + "overlap": "Canonicale54523517d0f03e58352e647c403a5af3e525a57 refreshed at every round; revision8/selected#7000 unchanged. Complete presubmission snapshot437openPRs at23:47:07UTC and7053Discussionrecords at23:48:13UTC. Sparse local coverage13 working records, including the new package, with10167 of10178 canonical note paths unsearched. ToikY round2 at23:33 reports no gain from scalar two-blocker/terminal tests and proposes Type-A mask support, a separate scope. No stronger complete open kappa or matching current-source temporal-buffer construction found; no novelty guarantee. Canonical main refetched at23:57UTC before submission; commit, priorities, selected record and applicable guidance unchanged.", + "open_questions": [ + { + "question": "Does an independent reviewer reproduce the complete timed-buffer application?", + "why_it_matters": "New owned lifetimes require fresh exact operator, storage, precision and compiler accounting.", + "first_step": "Run the registered certificate/native/application checks and inspect the temporal coefficient and lifecycle controls.", + "blocked_by": "Independent human/formal acceptance and maintainer admission remain." + }, + { + "question": "Does another fully charged causal history improve the successor word?", + "why_it_matters": "The finite one-path search stopped at the first positive and proves no ceiling.", + "first_step": "Refresh canonical guidance and overlap, pin the new word, then name a distinct bounded temporal domain.", + "blocked_by": "No later gain or full temporal optimality is established." + } + ], + "stop_rule": "One new fully checked invoice; refresh before any further research round." +} diff --git a/research/p104-causal-buffer-split/VALIDATION.md b/research/p104-causal-buffer-split/VALIDATION.md new file mode 100644 index 0000000000..a2e1acb1f0 --- /dev/null +++ b/research/p104-causal-buffer-split/VALIDATION.md @@ -0,0 +1,39 @@ +# Validation status and limits + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. Apache-2.0. + +All three direct commands passed on CPython 3.14.7: the timed certificate, complete native and full 17-stage application. Final registered isolated Python 3.12.16 replay passed all three commands and matched every frozen receipt field. REPLAY.txt retains the actual output; the process exited zero. Metadata was marked completed afterwards, explaining outcome=partial in the runner line. All 23 frozen scientific code, input, manifest and receipt hashes remained unchanged. + +The first native attempt stopped at the predecessor envelope's exact lifecycle census (54,43,51). The candidate actually has (56,44,53). Counted adapters now preserve the check against that exact new tuple in both precision paths. The complete native rerun passed, including a new valid-grammar extra-lifetime mutation that the census rejects. No frozen source bytes were edited and the failed attempt is not counted as a pass. + +Reproduction uses three explicitly registered commands: verify_certificate.py, verify_native.py and verify.py. They compare every certificate/native/application receipt field. The predecessor archive is authenticated by complete inventory, byte size, Git blob and SHA256, and reconstructed native words are compared by canonical decompressed bytes. + +The certificate checks every timed row/column coefficient and all ten temporal/cost controls. The native checks both operator directions, full inventory/deltas, independent rational and integer 1125/F25 grids, F24 and odd-scale rejection, explicit owned lifecycle and peak, 18 corruption controls, five 512-column chart/phase tests, the full 18-stage ingredient invoice/ordinary/precision and finite native/signed physical routes. The full 17-stage application must separately cover all 3,039 paid/helper maps and 104 main boundaries, actual caller grids/envelopes, ordinary/owned-stock/physical/fixed-tape costs, both directed prices and 54+4 outer conditions. + +Finite evidence does not discharge native_all_columns, owned_erasure, compiler, precision_tape or analytic_recovery as universal framework obligations. Human/formal acceptance, maintainer admission and compiled top-level execution remain. Hosted CI will be reported separately at the exact public head. + + +Direct commands (all exit zero): + +```sh +python3 -B research/p104-causal-buffer-split/verify_certificate.py --out /tmp/kappa-temporal-certificate-result.json +python3 -B research/p104-causal-buffer-split/verify_native.py --out /tmp/kappa-temporal-native-result.json +python3 -B research/p104-causal-buffer-split/verify.py --out /tmp/kappa-temporal-application-result.json +``` + +These generated the frozen CERTIFICATE.json, NATIVE-RESULT.json and RESULT.json +receipts. The registered check reruns without --out and compares every field. +There are ten certificate controls and 18 native controls, including repeated +certificate checks; these counts are not added as 28 distinct controls. + + +Publication retains a package-only commit on the older canonical ancestor +66849e1475c930fd7732b1a0067ffee7e1e95f60, avoiding unrelated workflow history +that the available OAuth scope cannot push. The scientific work is based on +canonical main e54523517d0f03e58352e647c403a5af3e525a57. The publication procedure +requires identical package Git trees and working-byte/mode checks. The source +history check applies to the canonical-based scientific commit; it is not a +claim that e545 is an ancestor of the older-parent publication commit. A shallow +publication-branch checkout should fetch canonical main before checking its +three provenance pins. All scientific runtime inputs are retained in the +complete authenticated package archive. diff --git a/research/p104-causal-buffer-split/VERIFY.json b/research/p104-causal-buffer-split/VERIFY.json new file mode 100644 index 0000000000..202c7785da --- /dev/null +++ b/research/p104-causal-buffer-split/VERIFY.json @@ -0,0 +1,39 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_certificate.py" + ], + "timeout_seconds": 120, + "checks": "Authenticate full37-file source and nested closure; reconstruct all seven timed prefix rows and one suffix column, unit boundary pairing, exact path chronology and entire candidate; reject ten temporal/cost corruptions and compare every certificate field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_native.py" + ], + "timeout_seconds": 510, + "checks": "Reconstruct full source/candidate; exact forward/adjoint, every owned lifecycle and full paid/productive delta; independent1125/F25 derivation; ingredient caller/price/ordinary/envelopes; phase and affected512-column maps, temporal/native/grid/owned controls and finite native/signed physical routes; every frozen receipt field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 570, + "checks": "Full unchanged17-stage signed caller; all3039 paid/helper maps and104 main boundaries; fresh native/caller grid and envelopes, owned stock, ordinary/physical/fixed-tape work, both directed prices and54+4 outer conditions; every application receipt field." + } + ] +} diff --git a/research/p104-causal-buffer-split/WITNESS.json b/research/p104-causal-buffer-split/WITNESS.json new file mode 100644 index 0000000000..ea95b5954b --- /dev/null +++ b/research/p104-causal-buffer-split/WITNESS.json @@ -0,0 +1,107 @@ +{ + "frame": 237, + "cut": 40066, + "pivot": 333, + "ranks": [ + 4, + 5 + ], + "c": { + "411": "-1", + "320": "-1/2", + "331": "-1/2", + "335": "-1/2" + }, + "d": { + "331": "-2" + }, + "gathers": [ + { + "cut": 40052, + "role": 49, + "frame": 237, + "paid_path": 0, + "coefficient": "1" + }, + { + "cut": 27482, + "role": 330, + "frame": 237, + "path": 5, + "coefficient": "2" + }, + { + "cut": 27429, + "role": 320, + "frame": 237, + "path": 2, + "coefficient": "-2" + }, + { + "cut": 27540, + "role": 23, + "frame": 237, + "path": 1, + "coefficient": "2" + }, + { + "cut": 27366, + "role": 323, + "frame": 237, + "path": 4, + "coefficient": "-1" + }, + { + "cut": 40066, + "role": 333, + "frame": 237, + "path": 6, + "coefficient": "-2" + }, + { + "cut": 27476, + "role": 321, + "frame": 237, + "path": 3, + "coefficient": "1" + } + ], + "injections": [ + { + "cut": 45280, + "role": 22, + "frame": 237, + "path": 0, + "coefficient": "-2" + } + ], + "boundary_basis_length": 8, + "paid_delta": { + "1": 1, + "5": 1, + "6": -1 + }, + "paid_path": 0, + "path": { + "role": 49, + "lo": 40052, + "hi": 47650, + "frame": 237, + "moves": [ + 47648 + ], + "old": 734, + "new": 127, + "old_paid": [ + 6 + ], + "new_paid": [ + 1, + 5 + ], + "cost": 0.009805013543460639, + "gain": 0.02236894474716955, + "private": false + }, + "owned_lifetimes_added": 2 +} diff --git a/research/p104-causal-buffer-split/WORD.json.gz b/research/p104-causal-buffer-split/WORD.json.gz new file mode 100644 index 0000000000..821002fe4b Binary files /dev/null and b/research/p104-causal-buffer-split/WORD.json.gz differ diff --git a/research/p104-causal-buffer-split/adapt.py b/research/p104-causal-buffer-split/adapt.py new file mode 100644 index 0000000000..b336903ac0 --- /dev/null +++ b/research/p104-causal-buffer-split/adapt.py @@ -0,0 +1,40 @@ +"""Counted adapters invalidate same-native reuse in Rohan Arun's #7113 checks. +All edits apply only to temporary copies of authenticated source. Apache-2.0. +Prepared for dillona with substantial OpenAI Codex assistance. +""" +from hashlib import sha256 + +def adapt(folder): + changes=[] + def patch(name,old,new): + path=folder/name;raw=path.read_text() + if raw.count(old)!=1:raise ValueError('Exact one-occurrence adapter: '+name+' '+old) + path.write_text(raw.replace(old,new));changes.append(dict(file=name,old=old,new=new)) + patch('emit_odd_type_ab.py', + 'invoice=next(x for x in json.loads((root/"SHORT-CALLER-RAW-PRICE.json").read_text())["rows"] if tuple(x["shape"])==shape)', + 'invoice=json.loads((root/"COHORT-PRICE.json").read_text())') + patch('check_odd_partial_admission.py', + 'previous=json.loads((root/"SHORT-ADMISSION-PARTIAL.json").read_text())\nassert previous["native_sha256"]==digest and not N["bad_inputs"]', + 'actual_native=ind.native(w)\nassert actual_native==N and not N["bad_inputs"], "Fresh complete native inventory and arbitrary-input adjoint"') + patch('check_odd_partial_admission.py','claim=Q(".00363797977")','claim=Q(".003642959019031")') + # ToikY's frozen exact_price() already shrinks this probe below the + # certified crossing. Recompute that rule in the caller's separate gate. + patch('check_odd_partial_admission.py', + 'tested=claim+Q(7,10**17)', + 'tested=claim+Q(7,10**17)\nwhile tested>=Q(reference["raw_bracket"][0]):\n tested=claim+(tested-claim)/10') + patch('check_odd_partial_admission.py', + 'g=gate(invoice,claim,tested,*bracket,r["gate"]["BIT_pin"])', + 'g=gate(invoice,claim,tested,*bracket,r["gate"]["BIT_pin"])\ntry:\n gate(invoice,claim,Q(bracket[0]),*bracket,r["gate"]["BIT_pin"])\nexcept AssertionError:\n crossing_probe_rejected=True\nelse:\n raise AssertionError("Probe at lower crossing unexpectedly accepted")') + patch('check_odd_partial_admission.py', + '"scope":"Reuse exact same native word all-column adjoint;', + '"crossing_probe_rejected":crossing_probe_rejected,"scope":"Reuse exact same native word all-column adjoint;') + patch('check_odd_precision.py', 'env=ModuleType("short_envelope")', + 'patch(\'(life, peak, owned_count) == (54, 43, 51)\',\'(life, peak, owned_count) == (56, 44, 53)\')\nenv=ModuleType("short_envelope")') + patch('check_odd_precision.py','previous=json.loads((root/"SHORT-PRECISION.json").read_text())','') + patch('check_odd_precision.py', + 'assert previous["native_sha256"]==sha and grid_receipt["caller_sha256"]==sha256(cpath.read_bytes()).hexdigest()', + 'assert grid_receipt["caller_sha256"]==sha256(cpath.read_bytes()).hexdigest()') + patch('check_odd_precision.py', + 'wg=previous["native_grid"]\nwr=previous["rounded_native"]\nwp={key:(Q(v["exact"]),v["witness"]) for key,v in wr["bounds"].items()}', + 'wg=grid.word_run(w, frac=25)\nwp,wr=env.native_envelope(w)\nwg=json.loads(json.dumps(wg,default=str));wr=json.loads(json.dumps(wr,default=str))\nassert wg==r["precision"]["word"] and wr==r["precision"]["rounded_native"], "Fresh changed-native grid and envelope"') + return dict(edits=changes,adapted_sha256={x['file']:sha256((folder/x['file']).read_bytes()).hexdigest() for x in changes}) diff --git a/research/p104-causal-buffer-split/certificate.py b/research/p104-causal-buffer-split/certificate.py new file mode 100644 index 0000000000..99f017221f --- /dev/null +++ b/research/p104-causal-buffer-split/certificate.py @@ -0,0 +1,116 @@ +"""Exact timed observation certificate; no discovery code is trusted. + +Causal-history identity: Ali Romman. Temporal coefficient methods and retiming: +Jerry Chen / CubeJerry; complete kernels: Matarener. Implementation for dillona +with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import defaultdict +from copy import deepcopy +from fractions import Fraction as Q +from support import L +from construct import construct + + +def observe(word, hit): + n = word['public'] + N = n+word['owned_fields'] + requests = [defaultdict(set), defaultdict(set)] + for side, field in enumerate(('gathers', 'injections')): + for obs in hit[field]: + requests[side][obs['cut']].add(obs['role']) + snapshots = [{}, {}] + rows = [{r: Q(1)} if r < n else {} for r in range(N)] + cols = [{r: Q(1)} if r < n else {} for r in range(N)] + events = word['program'] + def save(side, cut, values): + for r in requests[side].get(cut, ()): + snapshots[side][cut, r] = dict(values[r]) + save(0, 0, rows) + for i, e in enumerate(events): + op, r = e[:2] + if op in ('INIT', 'CLEAR'): + rows[r] = {} + elif op == 'SCALE': + rows[r] = {k: Q(e[-2])*q for k, q in rows[r].items()} + elif op in ('ADD', 'COPY'): + if op == 'COPY': + L.need(not rows[r], 'Every source COPY destination is ideal zero') + L.add(rows[r], rows[e[2]], Q(e[-2])) + save(0, i+1, rows) + save(1, len(events), cols) + for i in reversed(range(len(events))): + e = events[i] + op, r = e[:2] + if op in ('INIT', 'CLEAR'): + cols[r] = {} + elif op == 'SCALE': + cols[r] = {k: Q(e[-2])*q for k, q in cols[r].items()} + elif op in ('ADD', 'COPY'): + L.add(cols[e[2]], cols[r], Q(e[-2])) + if op == 'COPY': + cols[r] = {} + save(1, i, cols) + return snapshots + + +def check(hit, snapshots): + result = {} + for side, field, target in ((0, 'gathers', 'c'), (1, 'injections', 'd')): + total = {} + seen = set() + for obs in hit[field]: + key = obs['cut'], obs['role'] + L.need(key in snapshots[side] and key not in seen, 'Distinct authenticated source observation') + seen.add(key) + L.need(obs['frame'] == hit['frame'], 'One accumulator frame') + L.need(obs['cut'] <= hit['cut'] if side == 0 else obs['cut'] >= hit['cut'], 'Causal observation clock') + q = Q(obs['coefficient']) + L.need(q != 0, 'Nonzero observation coefficient') + L.add(total, snapshots[side][key], q) + want = {int(k): Q(q) for k, q in hit[target].items()} + L.need(total == want, 'Every timed source coefficient for '+target) + result[target] = {str(k): str(v) for k, v in sorted(total.items())} + c, d = ({int(k): Q(q) for k, q in hit[s].items()} for s in ('c', 'd')) + L.need(sum(q*d.get(r, 0) for r, q in c.items()) == 1, 'Unit boundary pairing') + return dict(status='PASS_EXACT_TIMED_OBSERVATIONS', gather_count=len(hit['gathers']), + injection_count=len(hit['injections']), latest_gather=max(x['cut'] for x in hit['gathers']), + retirement_cut=hit['cut'], earliest_injection=min(x['cut'] for x in hit['injections']), + vectors=result, boundary_pairing='1') + + +def controls(word, hit, paths, snapshots=None): + snapshots = observe(word, hit) if snapshots is None else snapshots + check(hit, snapshots) + def rejected(action): + try: + action() + except (ValueError, AssertionError): + return True + raise ValueError('Temporal corruption control accepted') + result = {} + for field in ('gathers', 'injections'): + bad = deepcopy(hit) + bad[field][0]['coefficient'] = str(2*Q(bad[field][0]['coefficient'])) + result['wrong_'+field+'_coefficient'] = rejected(lambda: check(bad, snapshots)) + bad = deepcopy(hit) + bad[field].pop(0) + result['omitted_'+field+'_observation'] = rejected(lambda: check(bad, snapshots)) + bad = deepcopy(hit) + bad['cut'] = max(x['cut'] for x in bad['gathers'])-1 + result['retirement_before_last_gather'] = rejected(lambda: check(bad, snapshots)) + bad = deepcopy(hit) + bad['injections'][0]['cut'] = hit['cut']-1 + result['injection_before_retirement'] = rejected(lambda: check(bad, snapshots)) + bad = deepcopy(hit) + bad['paid_delta'] = {} + result['omitted_paid_midpoint_cost'] = rejected(lambda: construct(word, bad, paths)) + bad = deepcopy(hit) + bad['path']['hi'] = bad['path']['moves'][0] + result['incomplete_paid_path'] = rejected(lambda: construct(word, bad, paths)) + bad = deepcopy(hit) + bad['ranks'] = list(reversed(bad['ranks'])) + result['wrong_productive_ranks'] = rejected(lambda: construct(word, bad, paths)) + bad = deepcopy(hit) + bad['gathers'][0]['cut'] = hit['cut']+1 + result['gather_after_retirement'] = rejected(lambda: construct(word, bad, paths)) + return result diff --git a/research/p104-causal-buffer-split/construct.py b/research/p104-causal-buffer-split/construct.py new file mode 100644 index 0000000000..0e1fc67ac5 --- /dev/null +++ b/research/p104-causal-buffer-split/construct.py @@ -0,0 +1,139 @@ +"""Causal-history two-buffer split; proposed constructor, not an admission. + +Ali Romman's owned-buffer identity and CubeJerry's contact-free retiming are +predecessors. Implementation for dillona with OpenAI Codex assistance. +Apache-2.0. The complete exact native and caller checks remain mandatory. +""" +from collections import defaultdict, Counter +from copy import deepcopy +from fractions import Fraction as Q +from support import L +from split import basis, inverse + + +def construct(word, hit, neutral_paths): + n, owned = word['public'], word['owned_fields'] + f, pivot, cut = hit['frame'], hit['pivot'], hit['cut'] + u, v = word['initial'][pivot], word['final'][pivot] + c, d = ({int(k): Q(q) for k, q in hit[s].items()} for s in ('c', 'd')) + main = set(word['live']) | {r+112 for r in word['live']} | set(word['hosted']['X2']) | set(word['hosted']['Y2']) + group = {r for r in range(n) if r not in main and (word['initial'][r], word['final'][r]) == (u, v)} + L.need(pivot in group and set(c) | set(d) <= group, 'One helper boundary group') + spaces = list(map(L.span, word['frames'])) + L.need(spaces[u] < spaces[f] < spaces[v], 'Strict productive boundaries') + L.need(hit['ranks'] == [len(word['frames'][f])-len(word['frames'][u]), len(word['frames'][v])-len(word['frames'][f])], 'Exact target ranks') + gathers, injections = defaultdict(list), defaultdict(list) + for obs in hit['gathers']: + L.need(obs['frame'] == f and obs['cut'] <= cut, 'Gather chronology') + gathers[obs['cut']].append(obs) + for obs in hit['injections']: + L.need(obs['frame'] == f and obs['cut'] >= cut, 'Injection chronology') + injections[obs['cut']].append(obs) + selected = {} + for obs in hit['gathers'] + hit['injections']: + if 'path' in obs: + p = neutral_paths[obs['path']] + L.need(p['role'] == obs['role'] and p['frame'] == f and p['lo'] <= obs['cut'] <= p['hi'], 'Observation belongs to its neutral path') + selected[(p['role'], p['lo'], p['hi'])] = (p, False) + if 'paid_path' in obs: + p = hit['path'] + L.need(obs['paid_path'] == hit['paid_path'] and p['role'] == obs['role'] and p['frame'] == f and p['lo'] <= obs['cut'] <= p['hi'], 'Observation belongs to its paid path') + if 'path' in hit: + p = hit['path'] + selected[(p['role'], p['lo'], p['hi'])] = (p, True) + # A pivot may use a neutral path even when its value is not gathered. + for p in neutral_paths: + if p['role'] == pivot and p['frame'] == f and p['lo'] <= cut <= p['hi']: + selected.setdefault((p['role'], p['lo'], p['hi']), (p, False)) + break + enter, leave, remove, delta = defaultdict(list), defaultdict(list), set(), Counter() + events = word['program'] + for p, paid in selected.values(): + r, lo, hi = p['role'], p['lo'], p['hi'] + actual = [i for i in range(lo, hi) if events[i][1] == r or (events[i][0] in ('ADD', 'COPY') and events[i][2] == r)] + L.need(actual == p['moves'] and actual, 'Complete contact-free interval') + path = [events[i] for i in actual] + L.need(all(e[0] == 'MOVE' and e[1] == r and e[4] == (r >= n) for e in path), 'Only owned-typed MOVEs') + L.need(all(a[3] == b[2] for a, b in zip(path, path[1:])), 'Continuous original path') + L.need(not remove.intersection(actual), 'Nonoverlapping changed intervals') + remove.update(actual) + if paid: + a, b = path[0][2], path[-1][3] + L.need((a, b) == (p['old'], p['new']) and (spaces[a] <= spaces[f] <= spaces[b] or spaces[b] <= spaces[f] <= spaces[a]), 'Paid nested midpoint') + before = [['MOVE', r, a, f, r >= n]] if a != f else [] + after = [['MOVE', r, f, b, r >= n]] if f != b else [] + else: + frames = [path[0][2]] + [e[3] for e in path] + L.need(frames == p['frames'] and f in frames, 'Exact retained neutral path') + at = frames.index(f) + before, after = path[:at], path[at:] + enter[lo].extend(before) + leave[hi].extend(after) + delta.update(abs(len(word['frames'][e[3]])-len(word['frames'][e[2]])) for e in before+after) + delta.subtract(abs(len(word['frames'][e[3]])-len(word['frames'][e[2]])) for e in path) + L.need({r: q for r, q in delta.items() if q} == {int(r): q for r, q in hit['paid_delta'].items()}, 'Complete paid histogram change') + boundary = basis(c, d, pivot, u) + out = deepcopy(word) + out['public'] = n+1 + out['owned_fields'] = owned+2 + out['initial'].append(f) + out['final'].append(v) + out['final'][pivot] = f + A, B = n+1+owned, n+2+owned + program = inverse(boundary) + current = word['initial'] + [None]*owned + first, last = min(gathers), max(injections) + + def mapped(event, after): + e = event.copy() + for pos in (1, 2) if e[0] in ('ADD', 'COPY') else (1,): + r = e[pos] + e[pos] = n if after and r == pivot else r+int(r >= n) + return e + + def original(event, after): + op, r = event[:2] + if op == 'MOVE': + L.need(current[r] == event[2], 'Retimed path entry') + current[r] = event[3] + elif op == 'INIT': + L.need(current[r] is None, 'Fresh original owned field') + current[r] = event[2] + elif op == 'CLEAR': + L.need(current[r] == event[2], 'Original owned clear') + current[r] = None + else: + L.need(current[r] == event[-1], 'Original scalar frame') + if op in ('ADD', 'COPY'): + L.need(current[event[2]] == event[-1], 'Original scalar source frame') + program.append(mapped(event, after)) + + for i in range(len(events)+1): + for e in enter[i]: + original(e, i > cut) + if i == first: + program.append(['INIT', A, f]) + for obs in gathers[i]: + L.need(current[obs['role']] == f, 'Literal scheduled gather frame') + r = obs['role'] + int(obs['role'] >= n) + program.append(['ADD', A, r, str(Q(obs['coefficient'])), f]) + if i == cut: + L.need(current[pivot] == f, 'Literal pivot residency') + program.extend([ + ['INIT', B, f], ['ADD', B, n, '1', f], ['ADD', B, A, '-1', f], + ['ADD', n, pivot, '1', f], ['ADD', n, A, '-1', f], ['ADD', n, B, '-1', f], + ['ADD', pivot, A, '1', f], ['ADD', pivot, n, '-1', f], ['CLEAR', A, f]]) + for obs in injections[i]: + L.need(current[obs['role']] == f, 'Literal scheduled injection frame') + r = n if obs['role'] == pivot else obs['role'] + int(obs['role'] >= n) + program.append(['ADD', r, B, str(Q(obs['coefficient'])), f]) + if i == last: + program.append(['CLEAR', B, f]) + for e in leave[i]: + original(e, i >= cut) + if i < len(events) and i not in remove: + original(events[i], i >= cut) + L.need(current == word['final'] + [None]*owned, 'All original final frames') + program += [mapped([*e[:-1], v], True) for e in boundary] + out['program'] = program + return out diff --git a/research/p104-causal-buffer-split/derive_grid.py b/research/p104-causal-buffer-split/derive_grid.py new file mode 100644 index 0000000000..f8cb37f00b --- /dev/null +++ b/research/p104-causal-buffer-split/derive_grid.py @@ -0,0 +1,36 @@ +"""Derive a finite common grid from every exact prefix row and scalar product. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from math import lcm +from pathlib import Path +import gzip,json,sys + +def derive(word): + n=word['public'];rows=[{r:Q(1)}for r in range(n)]+[{}for _ in range(word['owned_fields'])] + denom=1;peak=Q(1);witness=None;visits=0 + def observe(row,i,kind): + nonlocal denom,peak,witness,visits + for v in row.values():denom=lcm(denom,v.denominator);visits+=1 + mass=sum(map(abs,row.values())) + if mass>peak:peak=mass;witness=[i,kind] + for i,e in enumerate(word['program']): + op,r=e[:2] + if op in('INIT','CLEAR'):rows[r]={} + elif op=='SCALE': + rows[r]={k:Q(e[2])*v for k,v in rows[r].items()};observe(rows[r],i,'scale') + elif op in('ADD','COPY'): + if op=='COPY':assert not rows[r] + product={k:Q(e[3])*v for k,v in rows[e[2]].items()};observe(product,i,'product') + row=rows[r].copy() + for k,v in product.items(): + value=row.get(k,Q(0))+v + if value:row[k]=value + else:row.pop(k,None) + rows[r]=row;observe(row,i,'stored') + odd=denom;frac=0 + while odd%2==0:odd//=2;frac+=1 + return dict(odd_scale=odd,fractional_bits=frac,unscaled_maximum_mass=str(peak),scaled_maximum_mass=str(peak*odd),mass_witness=witness,coefficient_visits=visits),rows +if __name__=='__main__': + w=json.load(gzip.open(sys.argv[1],'rt'));result,rows=derive(w) + Path(sys.argv[2]).write_text(json.dumps(result,indent=2)+'\n');print(result) diff --git a/research/p104-causal-buffer-split/inputs/previous-composition.tar b/research/p104-causal-buffer-split/inputs/previous-composition.tar new file mode 100644 index 0000000000..754ba970c2 Binary files /dev/null and b/research/p104-causal-buffer-split/inputs/previous-composition.tar differ diff --git a/research/p104-causal-buffer-split/price.py b/research/p104-causal-buffer-split/price.py new file mode 100644 index 0000000000..b1d1697f73 --- /dev/null +++ b/research/p104-causal-buffer-split/price.py @@ -0,0 +1,53 @@ +"""Recompute both source invoices and two exact crossing engines. +Retains Rohan Arun's caller adapters and ToikY's attributed price engines. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +from hashlib import sha256 +from fractions import Fraction as Q +import gzip,importlib.util,json,sys + +def load(name,path): + spec=importlib.util.spec_from_file_location(name,path);obj=importlib.util.module_from_spec(spec);sys.modules[name]=obj;spec.loader.exec_module(obj);return obj + +def read(path): + raw=Path(path).read_bytes();return json.loads(gzip.decompress(raw) if raw[:2]==b'\x1f\x8b' else raw) + +def normalized(value):return json.loads(json.dumps(value,default=str)) + +def main(native,caller,previous_composition,folder): + source=load('composition_native_source',native/'source.py') + with source.sources() as (vendor,archive,rank9,bundle,parent,word): + sys.path.insert(0,str(folder)) + model=load('composition_signed_model',folder/'signed_model.py');ind=model.signed_model() + code=(folder/'independent.py').read_text();part=code[code.index('def invoices('):code.index('def ordinary(')] + assert part.count('assert calls==18')==1 + part=part.replace('assert calls==18',"assert calls==C['stages']") + old="elif e[1]=='IDLE_ONE':P[8*len(e[3])]+=ports";assert part.count(old)==1 + part=part.replace(old,"elif e[1] in ('IDLE_ONE','IDLE_ODD'):P[8*len(e[3])+(e[1]=='IDLE_ODD')]+=ports") + exec(compile(part,str(folder/'independent.py'),'exec'),ind.__dict__) + C=read(caller/'expected/ODD-TYPE-AB-CALLER.json') + old_word=word;new_word=read(native/'WORD.json.gz') + old_result=read(parent/'NATIVE-RESULT.json');new_result=read(native/'NATIVE-RESULT.json') + inventories=[ind.native(w) for w in (old_word,new_word)] + for n,r,w in zip(inventories,(old_result,new_result),(old_word,new_word)): + assert normalized(n)==r['native'] and not n['bad_inputs'] + assert sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest()==r['word_canonical_sha256'] + before,after=[ind.invoices(w,C,n) for w,n in zip((old_word,new_word),inventories)] + previous=read(previous_composition/'RESULT.json')['price'] + assert normalized(before)==previous['after'],'Entire reconstructed current666fd composition invoice' + G=load('composition_price_engine',bundle/'gate.py') + gate,price=G.exact_price(vendor,archive,before,after,{'gate':previous['gate']}) + assert Q(gate['claim'])>Q(new_result['gate']['claim']) + native_invoice={k:({int(r):v for r,v in value.items()} if k in ('T','P') else value) for k,value in new_result['invoice'].items()} + directed=G.module('composition_native_comparator',vendor/'interval_gate.py') + assert directed.moment(G.signed(native_invoice),Q(gate['claim']))[1]<0,'The separately checked18-stage ingredient invoice rejects the17-stage claim' + record=normalized(dict(before=before,after=after,gate=gate,price=price,native_baseline_rejects_new_claim=True, + old_native=old_result['word_canonical_sha256'],new_native=new_result['word_canonical_sha256'])) + with (folder/'CURRENT-PRICE.json').open('x') as f:json.dump(record,f,indent=2) + with (folder/'COHORT-PRICE.json').open('x') as f:json.dump(dict(target=after['T'],paid=after['P'],bracket=gate['raw_bracket']),f,indent=2) + print('PASS two reconstructed invoices and both exact price engines',price['claim_decimal'],flush=True) + +if __name__=='__main__': + assert __debug__ + main(*map(Path,sys.argv[1:])) diff --git a/research/p104-causal-buffer-split/source.py b/research/p104-causal-buffer-split/source.py new file mode 100644 index 0000000000..0ec9bdf861 --- /dev/null +++ b/research/p104-causal-buffer-split/source.py @@ -0,0 +1,49 @@ +"""Authenticate #666fd composition's complete source closure and reconstruct its native word. +Prepared for dillona with OpenAI Codex assistance. Apache-2.0. +All source authors and nested notices remain credited. +""" +from contextlib import contextmanager +from hashlib import sha256,sha1 +from pathlib import Path +import gzip,importlib.util,json,sys,tarfile,tempfile +HERE=Path(__file__).resolve().parent + +def need(ok,why): + if not ok:raise ValueError(why) +def read(path): + raw=Path(path).read_bytes();return json.loads(gzip.decompress(raw) if raw[:2]==b'\x1f\x8b' else raw) +def canonical(obj):return json.dumps(obj,sort_keys=True,separators=(',',':')).encode() +def load(name,path): + spec=importlib.util.spec_from_file_location(name,path);obj=importlib.util.module_from_spec(spec);sys.modules[name]=obj;spec.loader.exec_module(obj);return obj + +@contextmanager +def bundles(): + pin=read(HERE/'INPUTS.json');archive=HERE/pin['archive'] + need(sha256(archive.read_bytes()).hexdigest()==pin['archive_sha256'],'Frozen complete #666fd composition export') + old_path=list(sys.path) + with tempfile.TemporaryDirectory(prefix='p104-temporal_buffer-source-') as tmp: + root=Path(tmp);pins={x['path']:x for x in pin['files']};seen=set() + with tarfile.open(archive) as tar: + for member in tar: + if member.isdir():continue + path=root/member.name + need(member.isfile() and member.name in pins and member.name not in seen and path.resolve().is_relative_to(root.resolve()),'Unique safe listed source member') + raw=tar.extractfile(member).read();p=pins[member.name] + need(len(raw)==p['size'] and sha256(raw).hexdigest()==p['sha256'] and sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==p['git_blob'],'Exact source Git blob and SHA256') + path.parent.mkdir(parents=True,exist_ok=True);path.write_bytes(raw);seen.add(member.name) + need(seen==set(pins),'Complete source inventory') + parent=root/pin['prefix'];imports=load('temporal_buffer_parent_sources',parent/'source.py') + try: + with imports.bundles() as (sources,composition,work):yield sources,parent,work + finally:sys.path[:]=old_path + +@contextmanager +def sources(): + with bundles() as (parts,composition,work): + parent=composition;original=load('temporal_buffer_native_source',parent/'source.py') + with original.sources() as (vendor,archive,rank9,bundle,oldparent,word): + emitter=load('temporal_buffer_parent_construct',parent/'construct.py') + word=emitter.construct(word,read(parent/'CHANGES.json')) + need(canonical(word)==gzip.decompress((parent/'WORD.json.gz').read_bytes()),'Every reconstructed previous composition native byte') + need(sha256(canonical(word)).hexdigest()=='9557c4682056ab7cc7cda89aa73865bef0e3948cc10b3c3061b0a944af05b96a','Exact frozen current native') + yield vendor,archive,rank9,bundle,parent,word diff --git a/research/p104-causal-buffer-split/split.py b/research/p104-causal-buffer-split/split.py new file mode 100644 index 0000000000..f1c7609653 --- /dev/null +++ b/research/p104-causal-buffer-split/split.py @@ -0,0 +1,155 @@ +"""Split independent helper jobs with three scalar basis changes. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Adapted for arbitrary counted owned-field inventory by @CubeJerry with OpenAI assistance. +Successor: OpenAI Codex for dillona excludes both hosted main planes from helper groups. +The source word and caller retain the credits in README.md. +Successors: dillona/OpenAI Codex choose a small smooth swap entry when pivot is zero; +then also when a nonzero pivot has a nonunit reciprocal, preserving the native alphabet. +""" +from copy import deepcopy +from fractions import Fraction as Q +from support import L + + +def inverse(program): + return [[e[0], *e[1:-2], + str(1/Q(e[-2]) if e[0] == 'SCALE' else -Q(e[-2])), e[-1]] + for e in reversed(program)] + + +def basis(a, b, pivot, frame): + """Return B with row pivot equal to a and B b equal to e_pivot.""" + L.need(sum(v*b.get(k, 0) for k, v in a.items()) == 1, 'Unit basis pairing') + roles = sorted(set(a) | set(b) | {pivot}) + values, program = dict(b), [] + + def emit(event): + program.append(event) + r, q = event[1], Q(event[-2]) + if event[0] == 'SCALE': + values[r] = values.get(r, 0)*q + else: + values[r] = values.get(r, 0)+q*values.get(event[2], 0) + + def swap_score(r): + q=b[r] + def smooth(x): + for prime in (2,3,5): + while x%prime==0:x//=prime + return x==1 + return (not(smooth(abs(q.numerator)) and smooth(q.denominator)), + abs(q.numerator).bit_length()+q.denominator.bit_length(),r) + j = pivot if b.get(pivot) and not swap_score(pivot)[0] else min((r for r in roles if b.get(r)),key=swap_score) + if j != pivot: + for event in [['ADD', pivot, j, '1', frame], + ['ADD', j, pivot, '-1', frame], + ['ADD', pivot, j, '1', frame], + ['SCALE', j, '-1', frame]]: + emit(event) + if values[pivot] != 1: + emit(['SCALE', pivot, str(1/values[pivot]), frame]) + for r in roles: + if r != pivot and values.get(r): + emit(['ADD', r, pivot, str(-values[r]), frame]) + L.need(all(values.get(r, 0) == int(r == pivot) for r in roles), 'Basis column') + inverse_rows = {r: {r: Q(1)} for r in roles} + for e in inverse(program): + if e[0] == 'SCALE': + inverse_rows[e[1]] = {k: Q(e[-2])*v for k, v in inverse_rows[e[1]].items()} + else: + L.add(inverse_rows[e[1]], inverse_rows[e[2]], Q(e[-2])) + row = {} + for r, q in a.items(): + L.add(row, inverse_rows[r], q) + L.need(row[pivot] == 1, 'Basis row coefficient') + for r in roles: + if r != pivot and row.get(r): + program.append(['ADD', pivot, r, str(row[r]), frame]) + return program + + +def check_cut(word, h): + """Check the whole prefix row and suffix column over the rationals.""" + n, cut, f, p = word['public'], h['cut_after'], h['frame'], h['pivot'] + a, b, c, d = ({int(k): Q(v) for k, v in h[s].items()} for s in ('a', 'b', 'c', 'd')) + main = set(word['live']) | {r+112 for r in word['live']} | set(word['hosted']['X2']) | set(word['hosted']['Y2']) + L.need(p < n and p not in main, 'A helper supplies the retained output role') + u, v = word['initial'][p], word['final'][p] + group = {r for r in range(n) if r not in main and + (word['initial'][r], word['final'][r]) == (u, v)} + L.need(set(c) | set(d) <= group, 'Both boundary vectors use one helper group') + L.need(L.span(word['frames'][u]) < L.span(word['frames'][f]) < L.span(word['frames'][v]), + 'Two strictly productive nested targets') + L.need(h['ranks'] == [len(word['frames'][f])-len(word['frames'][u]), + len(word['frames'][v])-len(word['frames'][f])], 'Declared split ranks') + rows = [{r: Q(1)} if r < n else {} for r in range(n+word['owned_fields'])] + current = word['initial']+[None]*word['owned_fields'] + for e in word['program'][:cut+1]: + op, r = e[:2] + if op == 'MOVE': + current[r] = e[3] + elif op in ('INIT', 'CLEAR'): + rows[r] = {} + current[r] = e[2] if op == 'INIT' else None + elif op == 'SCALE': + rows[r] = {k: Q(e[-2])*x for k, x in rows[r].items()} + elif op == 'COPY': + rows[r] = {k: Q(e[-2])*x for k, x in rows[e[2]].items()} + else: + L.add(rows[r], rows[e[2]], Q(e[-2])) + L.need(all(current[r] == f for r in set(a) | set(b) | {p}), 'One intermediate chart') + total = {} + for r, q in a.items(): + L.add(total, rows[r], q) + L.need(total == c, 'Exact prefix functional; no other input') + column = [b.get(r, Q(0)) for r in range(n+word['owned_fields'])] + for e in word['program'][cut+1:]: + op, r = e[:2] + if op in ('INIT', 'CLEAR'): + column[r] = Q(0) + elif op == 'SCALE': + column[r] *= Q(e[-2]) + elif op == 'COPY': + column[r] = Q(e[-2])*column[e[2]] + elif op == 'ADD': + column[r] += Q(e[-2])*column[e[2]] + L.need(column == [d.get(r, Q(0)) for r in range(n+word['owned_fields'])], 'Exact suffix direction; no other output') + L.need(sum(x*b.get(r, 0) for r, x in a.items()) == + sum(x*d.get(r, 0) for r, x in c.items()) == 1, 'Both independent pairings') + return a, b, c, d + + +def split(word, h): + a, b, c, d = check_cut(word, h) + n, p, f, cut = word['public'], h['pivot'], h['frame'], h['cut_after'] + u, v = word['initial'][p], word['final'][p] + + def shift_owned(event): + e = event.copy() + e[1] += int(e[1] >= n) + if e[0] in ('ADD', 'COPY'): + e[2] += int(e[2] >= n) + return e + + def use_successor(event): + e = event.copy() + if e[1] == p: + e[1] = n + if e[0] in ('ADD', 'COPY') and e[2] == p: + e[2] = n + return e + + boundary, middle = basis(c, d, p, u), basis(a, b, p, f) + out = deepcopy(word) + out['public'] = n+1 + out['initial'].append(f) + out['final'].append(v) + out['final'][p] = f + out['program'] = inverse(boundary) + out['program'] += [shift_owned(e) for e in word['program'][:cut+1]] + out['program'] += [shift_owned(e) for e in middle] + out['program'] += [use_successor(shift_owned(e)) for e in inverse(middle)] + out['program'] += [use_successor(shift_owned(e)) for e in word['program'][cut+1:]] + out['program'] += [use_successor([*e[:-1], v]) for e in boundary] + return out diff --git a/research/p104-causal-buffer-split/support.py b/research/p104-causal-buffer-split/support.py new file mode 100644 index 0000000000..192cd38d27 --- /dev/null +++ b/research/p104-causal-buffer-split/support.py @@ -0,0 +1,18 @@ +"""Small exact sparse operations, retained from Ali Romman/CubeJerry. Apache-2.0.""" +class L: + @staticmethod + def need(ok, why): + if not ok: raise ValueError(why) + @staticmethod + def add(dst, src, q): + for k,v in tuple(src.items()): + value=dst.get(k,0)+q*v + if value: dst[k]=value + else: dst.pop(k,None) + @staticmethod + def span(basis): + out={0} + for v in basis: + L.need(type(v) is int and 00,'Ordinary allowance') + gate,price=G.exact_price(vendor,archive,before,invoice,previous) + manifest=read(vendor/'INDEPENDENT-SOURCES.json');P=load('rechart_bit_binding',archive/'verify.py');P.bit_binding(I,manifest) + precision=base.precision(vendor,new,C,gate,manifest) + need(precision['word']['odd_scale_lcm']==1125 and precision['word']['dyadic_height']==25,'Fresh ingredient precision') + print('PASS full ingredient invoice, ordinary, precision, both prices and outer gates',flush=True) + charts=chart_check(vendor,old,new) + from certificate import controls as temporal_controls + controls=temporal_controls(old,hit,paths) + scalar=next(i for i,e in enumerate(new['program'])if e[0]=='ADD') + controls['wrong_boundary_scalar_coefficient']=bool(I.native(new,mutant=scalar)['bad_inputs']) + bad=deepcopy(new);i=next(i for i,e in enumerate(bad['program'])if e[0]=='MOVE');bad['program'][i][2]=-1 + controls['wrong_move_source']=rejects(lambda:I.native(bad)) + bad=deepcopy(new);bad['final'][hit['pivot']]=old['final'][hit['pivot']] + controls['omitted_retiring_output_frame']=rejects(lambda:I.native(bad)) + A=new['public']+old['owned_fields'] + bad=deepcopy(new);bad['program']=[e for e in bad['program']if not(e[0]=='INIT'and e[1]==A)] + controls['omitted_accumulator_init']=rejects(lambda:I.native(bad)) + bad=deepcopy(new);i=next(i for i,e in enumerate(bad['program'])if e[0]=='CLEAR'and e[1]==A);bad['program'][i][1]=hit['pivot'] + controls['public_erasure_rejected']=rejects(lambda:I.native(bad)) + owned_check=G.module('temporal_owned_census',vendor/'retained/query-only-precision-envelope/envelopes.py',(('(life, peak, owned_count) == (54, 43, 51)','(life, peak, owned_count) == (56, 44, 53)'),)) + need(owned_check.validate_word(new)['lifetimes']==56,'Fresh exact owned census in envelope validator') + bad=deepcopy(new);bad['program']=[['INIT',A,hit['frame']],['CLEAR',A,hit['frame']]]+bad['program'] + controls['extra_uncharged_owned_lifetime']=rejects(lambda:owned_check.validate_word(bad)) + grid_engine=G.module('rechart_grid_controls',vendor/'retained/odd-native-common-grid/independent_bounds.py') + controls['insufficient_odd_grid']=rejects(lambda:grid_engine.word_run(new,375,25)) + controls['insufficient_fractional_grid']=rejects(lambda:grid_engine.word_run(new,1125,24)) + need(all(controls.values()),'All native corruption controls') + physical_checks=[] + with tempfile.TemporaryDirectory(prefix='rechart-physical-') as tmp: + path=Path(tmp)/'word.json.gz';path.write_bytes(gzip.compress(canonical(new),mtime=0)) + for command,args in [(vendor/'frozen/verify_host3_odd.py',[path,'1125']),(vendor/'frozen/physical.py',[path,vendor/'frozen/clifford_exact.py','1000000009','11'])]: + subprocess.run([sys.executable,'-I','-B',str(command),*map(str,args)],check=True);physical_checks.append(command.name) + digest=sha256(canonical(new)).hexdigest() + engine=G.module('rechart_signed_routes',rank9/'physical_child.py',(('cca66a7ec924bab47ccd1410968d16e071a01dc6110b5c08040bd207f753d066',digest),)) + capture=io.StringIO() + with contextlib.redirect_stdout(capture):engine.main(path,vendor/'data/caller.json',caller_path) + signed_routes=json.loads(capture.getvalue()) + need(signed_routes['status']=='PASS_PHYSICAL_RANK9_ALGEBRA' and signed_routes['paid_calls']==32,'Signed physical fields') + need(1000*sum(len(row['caller_fields'])*row['ordinary_elementary_units'] for row in signed_routes['bindings'])==routes,'Actual signed-route charge') + print('PASS affected Gaussian chart columns, phase, corruption controls and finite physical replay',flush=True) + return normalized(dict(status='PASS_P104_CAUSAL_BUFFER_NATIVE',source_head=read(HERE/'INPUTS.json')['head'],word_canonical_sha256=digest,native=N,forward=forward_receipt,grid=grid,derived_grid=derived,caller=symbolic,invoice=invoice,ordinary=ordinary,gate=gate,price=price,precision=precision,charts=charts,controls=controls,physical_checks=physical_checks,signed_routes=signed_routes,limitations=['Five inherited framework assumptions remain.','Source-aware retained engines are not independent human/formal acceptance.','The complete 17-stage application is checked separately.'])) +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--out',type=Path);a=p.parse_args();r=run() + if a.out: + with a.out.open('x') as f:json.dump(r,f,sort_keys=True,indent=2);f.write('\n') + else:need(r==read(HERE/'NATIVE-RESULT.json'),'Every frozen native receipt field') + print(r['status'],r['gate']['claim'],flush=True)