diff --git a/research/p104-temporal-chart120-split/APPLICATION.md b/research/p104-temporal-chart120-split/APPLICATION.md new file mode 100644 index 0000000000..51c6e3c2b4 --- /dev/null +++ b/research/p104-temporal-chart120-split/APPLICATION.md @@ -0,0 +1,70 @@ +# Complete signed 17-stage application + +All three direct CPython 3.14.7 commands passed. Final registered isolated +Python 3.12.16 comparison passed all three commands and every frozen receipt field. These are conditional finite checks; +the selected frontier and five framework assumptions are unchanged. + +The full application has **110434 paid positions**, **22342 +productive fields**, surplus **1424**, and zero empty-root credit. +Both invoices are reconstructed from the exact native words and unchanged +signed caller. The claim **κ=.003643180671645** improves #7140 by +**.000000221652614**. Both directed price engines reject the predecessor invoice +at the new claim. The current invoice crossing is strictly bracketed by + +``` +(0.0036431806716457592014331762194701, + 0.0036431806716457592014331762194702). +``` + +| Fresh check | Result | +|---|---:| +|Ordinary source-unit work|779260044 < 1000000000| +|Precision context c|2362| +|Context height / mass exponent|406 / 1181| +|Native scale / fractional bits|1125 / 25| +|Owned banks per raw occurrence|935| +|Scalar service bound|42835744| +|Scalar step coefficient|44916533100544| +|Monomial map slots|298400| +|Elementary record bound|25442777600| +|Actual ambient / compiler cap|145 / 153| +|Maximum scalar numerator bits|24| +|Kstar / context-bound bits|14093 / 14104| + +The 17 calls reserve 55 owned labels each, **935 banks**, including both new +buffers. Ordinary accounting includes all 58 native owned lifetimes; peak +simultaneous ownership is 44. Every added INIT, CLEAR, ADD, SCALE, MOVE, +arbitrary public input and conversion is charged. These are source-unit bounds +and compiler substitutions, not measured machine-instruction counts or a +compiled top-level benchmark. + +The unchanged caller has 4,783 symbolic events; its rational and integer replays +pass, and its SHA256 remains `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`. +Every one of the **3,038 paid/helper chart maps and 104 main boundaries** is +checked with phase and owner bindings. The native check separately covers +six sets of 512 Gaussian columns: (3,120), (3,127), (120,127), (120,207), +(597,120), (597,207). No previously absent native pair is introduced, but the +affected pairs are explicitly rechecked. Finite physical routes also pass. + +The freshly derived grid has maximal scaled mass +`814448574117075/8192` and fractional height 25; F24 is rejected. +Both precision paths preserve the exact lifecycle assertion at (58,44,55). +Rounded native and caller envelopes are recomputed with every new operation; +predecessor receipts are not evidence for the changed word. + +The full gate has H=16502900000000000000000, written log power 2236, +and compiler gap 1/100000000000000000. All **54 strict and four functional** +outer conditions pass. The lower-crossing probe is rejected; the claim and its +accepted probe lie strictly below the crossing. No empty credit is used. +The separate 18-stage ingredient has ordinary work 853086328 +and claim 3642574878947/1000000000000000; it is distinct from the full 17-stage claim. + +RESULT.json, NATIVE-RESULT.json and CERTIFICATE.json retain the full receipts. +The registered hook authenticates the complete predecessor closure and six +byte-identical implementations, then compares every frozen receipt field. +It does not establish human/formal acceptance, maintainer admission or a +compiled top-level multiplication theorem. See PROOF.md, VALIDATION.md and NOTICE. + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. +Credit Ali Romman, CubeJerry, Matarener, Rohan Arun, ToikY and every retained +source author. Apache-2.0. diff --git a/research/p104-temporal-chart120-split/CERTIFICATE.json b/research/p104-temporal-chart120-split/CERTIFICATE.json new file mode 100644 index 0000000000..e905c97552 --- /dev/null +++ b/research/p104-temporal-chart120-split/CERTIFICATE.json @@ -0,0 +1,33 @@ +{ + "boundary_pairing": "1", + "candidate_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "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": 39280, + "gather_count": 2, + "injection_count": 6, + "latest_gather": 39225, + "neutral_paths": 7, + "paid_paths": 1, + "retirement_cut": 39225, + "source_sha256": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "status": "PASS_EXACT_TIMED_OBSERVATIONS", + "vectors": { + "c": { + "1449": "1" + }, + "d": { + "1449": "1" + } + } +} diff --git a/research/p104-temporal-chart120-split/DISCOVERY.json b/research/p104-temporal-chart120-split/DISCOVERY.json new file mode 100644 index 0000000000..e0e1e8202e --- /dev/null +++ b/research/p104-temporal-chart120-split/DISCOVERY.json @@ -0,0 +1,44 @@ +{ + "source_commit": "a95783a8c861248a759136d4285ea725499cf231", + "native": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "optional_search": { + "status": "EXACT_TEMPORAL_NOMINATION", + "counts": { + "observations_0": 14593, + "neutral_observations_0": 10438, + "observations_1": 22345, + "neutral_observations_1": 10438, + "frames": 1093, + "helpers": 620, + "prefix_pure": 126, + "suffix_pure": 99, + "basis_pairs": 100, + "causal_pairs": 100, + "causal_nonzero_pairs": 1, + "resident_pairs": 1, + "paid_paths_total": 7667, + "paid_paths_processed": 715 + }, + "frame_counts": [], + "seconds": 27.674129247665405, + "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": [ + 4793, + 4794, + 4799, + 9513, + 10178, + 10179, + 10325 + ], + "retained_paid_path_id": 714, + "scope": "First positive on exact7140 after715 of7667 individually affordable one-path candidates. Public exact certificate and full native/application do not trust discovery." +} diff --git a/research/p104-temporal-chart120-split/ENVIRONMENT.json b/research/p104-temporal-chart120-split/ENVIRONMENT.json new file mode 100644 index 0000000000..a0fb246e50 --- /dev/null +++ b/research/p104-temporal-chart120-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 frozen receipt field matched" + }, + "source_pins": "INPUTS.json and nested manifests", + "parallelism": "No subagents; serial scientific runs; isolated worktree", + "completed_utc": "2026-11-11T00:32:12.219433+00:00" +} diff --git a/research/p104-temporal-chart120-split/INPUTS.json b/research/p104-temporal-chart120-split/INPUTS.json new file mode 100644 index 0000000000..ab6880bc10 --- /dev/null +++ b/research/p104-temporal-chart120-split/INPUTS.json @@ -0,0 +1,188 @@ +{ + "head": "a95783a8c861248a759136d4285ea725499cf231", + "prefix": "research/p104-causal-buffer-split", + "archive": "inputs/previous-causal-buffer.tar", + "archive_sha256": "66f517dd17dbdf1f3963dd183981b3e83129e6d6e80904aa73d8a8b83f22ffe0", + "files": [ + { + "path": "research/p104-causal-buffer-split/APPLICATION.md", + "size": 3522, + "sha256": "7e126cb20880b49f6408015b748556975efdbd412a7b2241020ec77bd7c1c8ee", + "git_blob": "09060b813a60fa3872cb3bbb2f71db1524028475" + }, + { + "path": "research/p104-causal-buffer-split/CERTIFICATE.json", + "size": 993, + "sha256": "059b6e2aa6e82a0a8356e67b59bcfec84b8a5fdbd97a84b5a2f966c6b0f7f258", + "git_blob": "a710f2790a6ee0c08e5120818becb7662bdf3e00" + }, + { + "path": "research/p104-causal-buffer-split/DISCOVERY.json", + "size": 1712, + "sha256": "862c2178233005aef75765ade36b6af09ddcb134855fd587c7e9c18a9667bad0", + "git_blob": "ef8a50579b7e986a633d4d5ceb99d22627b8aa41" + }, + { + "path": "research/p104-causal-buffer-split/ENVIRONMENT.json", + "size": 541, + "sha256": "cbbd3573bd8579344838f4e3cd3ef52611de741490176961d322fbc74e6f61b7", + "git_blob": "c27ce4dbd82622a158cdb5808511c6fde5322509" + }, + { + "path": "research/p104-causal-buffer-split/INPUTS.json", + "size": 9540, + "sha256": "eb67979e3bf5bb98a3c8ff46c00fd5f94f8826f4867f155e653841e57f0f1361", + "git_blob": "8142bf678337763a445beaffbecff2683356d5c2" + }, + { + "path": "research/p104-causal-buffer-split/NATIVE-RESULT.json", + "size": 74498, + "sha256": "afec1967fbfd9f964e54dae666d172b052e9dc965a1f5cce93732e09d8b3b58a", + "git_blob": "f970721a2f50b1f49b821b491ff3b35cfb54a6b5" + }, + { + "path": "research/p104-causal-buffer-split/NOTICE", + "size": 826, + "sha256": "ca74f81c158d44fd8816984f9c59b022067b4ec3c99eb437c8e25ee970b4eb53", + "git_blob": "780b4f6e390051c8a095c5d8419e2bebdba72cd7" + }, + { + "path": "research/p104-causal-buffer-split/PATHS.json", + "size": 1086, + "sha256": "de30460f010e7799c71fe95dc81f0073982c5f3ec89323d4e580d9050d51cd4f", + "git_blob": "c4e97f5b6f64b1397d8234c7823ecd7df2c7b686" + }, + { + "path": "research/p104-causal-buffer-split/PROOF.md", + "size": 6917, + "sha256": "5216f9d71fa2911c82607d10ff359924edc43b438ed76e3cb751317338476696", + "git_blob": "74745ea81370048c1440e0d5c2e3b504052a76ed" + }, + { + "path": "research/p104-causal-buffer-split/README.md", + "size": 5242, + "sha256": "527252fc7d813f5ad00173957b76cdd0cca392b032c0fe228e322e3aea18ce42", + "git_blob": "39d808ae7d583fcdbf950850e41fa2fc565a619e" + }, + { + "path": "research/p104-causal-buffer-split/REPLAY.txt", + "size": 4068, + "sha256": "45a18764bd25b7059ca36baecf571d9ae55c6300bb6538f82ff343f753b86f9f", + "git_blob": "89287f3c495162cbccf623e1afa0c3ee12ab9caa" + }, + { + "path": "research/p104-causal-buffer-split/RESULT.json", + "size": 77060, + "sha256": "e061d124849b9f29595bf1ab5fda12c3bd923d5fee1b119813ae0c771048e65e", + "git_blob": "b7f91ee924d4cc74cea61fbc5f5827f3eee888d2" + }, + { + "path": "research/p104-causal-buffer-split/SOURCES.json", + "size": 856, + "sha256": "8b58a30ae55396b8d108de4ee2c7c6ac75dc1096948c9ac3796c20b21b1c9372", + "git_blob": "c4150ae39789502a4adf89e8f5235995d458a72e" + }, + { + "path": "research/p104-causal-buffer-split/TASK.json", + "size": 12796, + "sha256": "eb3c2861c57be4a380be1294ad52800dd0f0cbb94d53d5dd03ffd674bce4df7d", + "git_blob": "69188d722f1c794137985eb85c302abbf206ae83" + }, + { + "path": "research/p104-causal-buffer-split/VALIDATION.md", + "size": 3763, + "sha256": "1c390af21b3b4176132ce90bf3f4b0c2fa5d88d30182e537e637addc7860927e", + "git_blob": "a2e1acb1f0fa1b1236e7e09637aabdc6a37995e5" + }, + { + "path": "research/p104-causal-buffer-split/VERIFY.json", + "size": 1476, + "sha256": "19f86066c089225b77bb649e28c98026e10926261afbf9eeb23fcbeb7035b0ff", + "git_blob": "202c7785da2e68839369f417f50e184e9ad1f192" + }, + { + "path": "research/p104-causal-buffer-split/WITNESS.json", + "size": 1609, + "sha256": "edced97c758ad82b32ee1e1e0013622ea8ac3d88070a77b7a37d519060793bfc", + "git_blob": "ea95b5954bb254ba3cd6081091efa47a288ce768" + }, + { + "path": "research/p104-causal-buffer-split/WORD.json.gz", + "size": 370998, + "sha256": "222851b3fa368e669fca09bfc7515bb19df1ad8690d49ff52cfa04e9776a6e1b", + "git_blob": "821002fe4b3444f28cdbdc605cd09c7812994f32" + }, + { + "path": "research/p104-causal-buffer-split/adapt.py", + "size": 3381, + "sha256": "bb0f103584e3fe5fa9866c1b2a3342848651f9aba12d8807f5474635c418ae84", + "git_blob": "b336903ac0a2df13cc91b8109f1af819da48daba" + }, + { + "path": "research/p104-causal-buffer-split/certificate.py", + "size": 5067, + "sha256": "15581732d5e07550a2fea1dcb17a1eb106a053ef69223c4c861d4e322149ce86", + "git_blob": "99f017221ffb972e55d8dd72ca61510d2569209f" + }, + { + "path": "research/p104-causal-buffer-split/construct.py", + "size": 7156, + "sha256": "2e07135e9c733bd0a6d61eb1d9c2bfbf5b482f599dcb6f82238e15ee9bd93018", + "git_blob": "0e1fc67ac51f6a87843dc3772a39e746836ee183" + }, + { + "path": "research/p104-causal-buffer-split/derive_grid.py", + "size": 1510, + "sha256": "ceb7a44ef19d72a16db7b43c65c85910d965499d1715436011de32af5d39dbb0", + "git_blob": "f8cb37f00bcd197d77bbb205dae3c1a40c0aa680" + }, + { + "path": "research/p104-causal-buffer-split/inputs/previous-composition.tar", + "size": 11683840, + "sha256": "efa1c93816997998dd61d214aa7c4e312a43e131b30a374ffccce2d5ccc91f71", + "git_blob": "754ba970c2c5cb694c670842f4c5f30f1155fd11" + }, + { + "path": "research/p104-causal-buffer-split/price.py", + "size": 3653, + "sha256": "e0c3d20e9c90f2eb7366e740b93c71360fe32121f68f6631da91541b69c321b5", + "git_blob": "b1d1697f73ec257f84b602b4552686bdcf7fc7c2" + }, + { + "path": "research/p104-causal-buffer-split/source.py", + "size": 3009, + "sha256": "dac1e3953bf62732fccdb050838a369f35490b27a0377362cdc42b800ad2d4fc", + "git_blob": "0ec9bdf861d5143955075f776ec234a00335e795" + }, + { + "path": "research/p104-causal-buffer-split/split.py", + "size": 6551, + "sha256": "999b9eeabe5cd1a7e3ec014d1a449f850b4ac9bfb19749cddef41ae12cd0b405", + "git_blob": "f1c76096534a7aea45a2f4b994d9de483695140d" + }, + { + "path": "research/p104-causal-buffer-split/support.py", + "size": 606, + "sha256": "f3e6eeb879480715c5c32c1a390a63c57d26ea1c9a9cbdb89b83ca34260e47f6", + "git_blob": "192cd38d27e4b732981b98730459a041dcfb52e7" + }, + { + "path": "research/p104-causal-buffer-split/verify.py", + "size": 3446, + "sha256": "2afce5cf164366755c39c2a3cfd29ef067695c6123912306391d55ca363d9f8a", + "git_blob": "638bdf0bf7a5bf00b5abf8cf07f5fecc234392de" + }, + { + "path": "research/p104-causal-buffer-split/verify_certificate.py", + "size": 1618, + "sha256": "0c79decfe1c0286e2aea72706579ccdd480dee8c31a50bda80bc52e44d1ea478", + "git_blob": "482d940bd3f6c4192d551c9901db9f7155626994" + }, + { + "path": "research/p104-causal-buffer-split/verify_native.py", + "size": 12357, + "sha256": "87e17930da8d6e01f917eae8a180ee1730c896a19e9d99e45a374799bb12a885", + "git_blob": "e7949017d7f4bd89ce5281bd78226fde7ee864e9" + } + ] +} diff --git a/research/p104-temporal-chart120-split/NATIVE-RESULT.json b/research/p104-temporal-chart120-split/NATIVE-RESULT.json new file mode 100644 index 0000000000..7f565c31ef --- /dev/null +++ b/research/p104-temporal-chart120-split/NATIVE-RESULT.json @@ -0,0 +1,3096 @@ +{ + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "new_pairs": [], + "rechecked_pairs": [ + { + "columns": 512, + "pair": [ + 3, + 120 + ], + "rank": 5 + }, + { + "columns": 512, + "pair": [ + 3, + 127 + ], + "rank": 9 + }, + { + "columns": 512, + "pair": [ + 120, + 127 + ], + "rank": 4 + }, + { + "columns": 512, + "pair": [ + 120, + 207 + ], + "rank": 3 + }, + { + "columns": 512, + "pair": [ + 597, + 120 + ], + "rank": 4 + }, + { + "columns": 512, + "pair": [ + 597, + 207 + ], + "rank": 7 + } + ], + "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": 15457904, + "fractional_bits": 25, + "mass_witness": [ + 65243, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "814448574117075/8192", + "unscaled_maximum_mass": "10859314321561/122880" + }, + "forward": { + "coefficient_positions": 2399401, + "fractional_bits": 25, + "grid": 1125, + "rows": 1549 + }, + "gate": { + "BIT_margin": "12411512105293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999994, + 0.9999999999999994 + ], + "claim": "3642574878947/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8832902883001984, + 0.8832902883001984 + ], + "derivative_upper": -407158.4591779271, + "gamma": [ + 0.9500022345745055, + 0.9500022345745055 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3642574878947/1000000000000000": [ + "124280541107893790030624913422081294579186673857870341940571305960055891859567/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62140270553946895015312456711040647289593336928935170970285652980027945930749/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364257487894707/100000000000000000": [ + "31070135276974019130514111687417391474682242740514443271197165259769284471477/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2485610822157921530441128934993391317974579419241155461695773220781542757757/2000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "364257487894707/100000000000000000": [ + 1.7182352379027027e-10, + 1.7182352379027027e-10 + ], + "3642574878947484894136692083587/1000000000000000000000000000000000": [ + 1.4042644931643019e-29, + 1.4042644931643019e-29 + ], + "36425748789474848941366920835871/10000000000000000000000000000000000": [ + -2.737117816072574e-29, + -2.737117816072574e-29 + ] + }, + "moment_margins": { + "364257487894707/100000000000000000": [ + "8591176189513513007244749336723531344273473057037603506875712327341963/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2147794047378378251811187334180882836068368264259400876718928087074071/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "3642574878947484894136692083587/1000000000000000000000000000000000": [ + "175533061645537734317996089799682353678965466896193/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "702132246582150937271984359198729414715861888658003/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36425748789474848941366920835871/10000000000000000000000000000000000": [ + "-17106986350453586923374097911755518120476665676307/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "-684279454018143476934963916470220724819066616512381/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "3642574878947484894136692083587/1000000000000000000000000000000000", + "36425748789474848941366920835871/10000000000000000000000000000000000" + ], + "tested": "364257487894707/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": 64552, + "CLEAR": 58, + "COPY": 1, + "INIT": 58, + "MOVE": 6274, + "SCALE": 3712 + }, + "owned_lifetimes": 58, + "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": 828, + "4": 225, + "5": 342, + "6": 15, + "7": 10, + "8": 6 + } + }, + "invoice": { + "P": { + "1": 72276, + "16": 416, + "2": 15372, + "24": 416, + "3": 14904, + "32": 416, + "4": 4050, + "40": 416, + "48": 416, + "5": 6156, + "56": 416, + "6": 270, + "64": 416, + "7": 180, + "8": 780, + "9": 32 + }, + "S": 1520, + "T": { + "1": 288, + "145": 208, + "17": 416, + "2": 360, + "25": 416, + "3": 846, + "33": 416, + "4": 3960, + "41": 416, + "49": 416, + "5": 1368, + "57": 416, + "6": 774, + "65": 416, + "7": 324, + "73": 416, + "8": 630, + "9": 11558 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036425748789474848941366920835870339081105850153418506344753516589", + "raw_crossing": "0.0036425748789474848941366920835870339081105850153418506344753516589" + }, + "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": 74655, + "helpers": { + "1": 16, + "2": 20, + "3": 47, + "4": 220, + "5": 76, + "6": 43, + "7": 18, + "8": 35, + "9": 619 + }, + "lifetimes": 58, + "owned_peak": 44, + "paid": { + "1": 3994, + "2": 854, + "3": 828, + "4": 225, + "5": 342, + "6": 15, + "7": 10, + "8": 6 + }, + "public": 1494, + "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": 853086328, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 232, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 146913672, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2796768, + "raw_upper": 835121304, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2188, + "moves": 6274, + "owned_lifetime": 232, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9894000, + "scalar_upper": 2069068 + }, + "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": "45956159174072599700841582644791226032878246665742377989239619323538481272388953891440180540388088742240770468280378465547661315735639618338871905743947692214814650360642126032855980654654145165140979341381631384417499442391959619139907958463895595691812487237603699748796032510207380134546694746086937496955809382451/236574025616993083824920739000090624000000000000000000000", + "strict_power_of_two": 865, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "29616632735008889987723864669486932497070637831470734783666538260854567629288254187204749600060590211733321049000538235023207847245638373455581433347863494578466000855117858207190477616979208080203835164518795688785599346238965692471730684933686424783859291289306213562161981546873842936614261449897092994374547079429191/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": "8832691723968155632874045929975398564786551111885085024810189376973185799995949721114375071784046437719311035145417194725203162446576265155688963389058810611408501349570404702103838484491310614580676841311465883444145620999219211568471128848460607291656727118420368408764850760855331486617673631932319690488807340772417909/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": "29616632735008889987723864669486932497070637831470734783666538260854567629288254187204749600060590211733321049000538235023207847245638373455581433347863494578466000855117858207190477616979208080203835164518795688785599346238965692471730684933686424783859291289306213562161981546873842936614261449897092994374547079429191/1135555322961566802359619547200434995200000000000000000000", + "strict_power_of_two": 872, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "91930729022622991031145128062391007822052473291176260672884445815057422443298154621990132410408338109389566592167242907383738233109195665876783029606824904405244094783108337225626267848371278767037764077860409567261303344229159653640809924604860070310376692876614116771907424056843031400302753422280689736417655294911096661836773959960705200153815348236683947397696351845258688706515999670271709948670416070231977877972354997180231702133904915976929297/655866440585504295186659233010595682288897598376131487118386096242688000000000000000000000000000000000000000000", + "strict_power_of_two": 1134, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19692, + "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": "45956159174072599700841582644791226032878246665742377989239619323538481272388953891440180540388088742240770468280378465547661315735639618338871905743947692214814650360642126032855980654654145165140979341381631384417499442391959619139907958463895595691812487237603699748796032510207380134546694746086937496955809382451/236574025616993083824920739000090624000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470734783666538260854567629288254187204749600060590211733321049000538235023207847245638373455581433347863494578466000855117858207190477616979208080203835164518795688785599346238965692471730684933686424783859291289306213562161981546873842936614261449897092994374547079429191/1135555322961566802359619547200434995200000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470734783666538260854567629288254187204749600060590211733321049000538235023207847245638373455581433347863494578466000855117858207190477616979208080203835164518795688785599346238965692471730684933686424783859291289305078006839019980071483317067061014901892994374547079429191/1135555322961566802359619547200434995200000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "45956159174072599700841582644791226032878246665742377989239619323538481272388953891440180540388088742240770468280378465547661315735639618338871905743947692214814650360642126032855980654654145165140979341381631384417499442391959619139907958463895595691812487237603699748796032510207380134546694746086937496955809382451/236574025616993083824920739000090624000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "29616632735008889987723864669486932497070637831470734783666538260854567629288254187204749600060590211733321049000538235023207847245638373455581433347863494578466000855117858207190477616979208080203835164518795688785599346238965692471730684933686424783859291289306213562161981546873842936614261449897092994374547079429191/1135555322961566802359619547200434995200000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "5823402494196099305778791202540497872481412974099026347934033941941701685991664452002734269253164083305522243644412084531946276068985302561/43317997854674026579270154846208000000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "16693087639615725533916213296460681729045693942687411209934986398270233460659361455152882859236959218858366635231054084168938444124037971871880527619/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "215422193601072158775310616724805421780858470440048717951612067705598616145513774098993637270103468673522666262936436046642934989922895305734344256579381263/138617593134956885053664495507865600000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "765172019110513572981361159774534395205342222069664266135531644656439595105606907202102906453796078346649916279250661452697994095861875412429122073315594060546724711/924117287566379233691096636719104000000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "1373227143923868540124128978974178199272734458981552312897880312565824473994447263086906528548481124972298261374501693693487444822393363643338726443923404375022676175252276833/693087965674784425268322477539328000000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "20823385219253020417470968328846275074595710152007697302419027153257563236371146175630287745056050493416634153017357578451504321440989659665106251535826519146505364497299571012273075967/4435762980318620321717263856251699200000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "85942816230796790420859464298982165823243771253866896756402681065649705790228180398241714955368777834667084749451035148723345143642343147945982214527044698240787518546279841814770403413000289409/1848234575132758467382193273438208000000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "930254244993030761229829268847188896082982635830002869030660303027776376733475139012978958522915318624379074269751600952568060041749363683736604650225754042867546673306314121765544743958107284696565432881/11089407450796550804293159640629248000000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "26698235516885785065997401492429286765678723263541767258530537508691916836518113304038254773754047858801303702030065788450136862655617544157694533191603859207713561379485405293371176375445379473185235945294260485474169099970193429899209183332138433/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "333036985153880054482618557948835050810077718958837599075958233614377432935129214904590964254108767725119165039716875017577506185587257705014793256324516642326569214815186508076759356886388864891369018091631966328897684730947587426960045648955243350271705887/44357629803186203217172638562516992000000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "1485186443597101445216199568250063900555675940653286398432659915350835358585925162952272504920638547411812411710663753465397700712051690704997053716009751991024496863287047562179115924143896745098966167647620960711450424493796776956313811651005470467350202380930352247/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "159734677813645691152644956749584034015104198491773109068710161969765290787424964853674001323059885655603191436327907438521998739114548295318750273905664553221338223772985053268051341133907248038897905558397602865078342768168153486334643565132851629871030941414204993059023613/19714502134749423652076728250007552000000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "980153410758705132757296517408018064903725752900401232367076893996376159569599148897453611976614129757346701114817339412303415113561923644503951945939274558474209734966799425409592526966603289684387053004554366146543277494587501479779052930519888604806790767750851725699425836221541519/354861038425489625737381108500135936000000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "96723013183992897325904658155556017573071866746652499726599227850986071404685541971431706697934471636500195968265340760502094545465296060780591710983704701467008516673542144991936285166414215090961511155240215194312306369153435131932312999975362200203274192145761905780286729747766121651796817/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "47249676043683272948772425497268865397768579217032573645376978207981014978611576356609716920428955337774349245425327416741972470493769979828418361091245197603326174717845285064036938661018365551839116645335111434861201980513565659736132885936081284600889741949840379773587162958152914437765214437310743/1419444153701958502949524434000543744000000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "97572789564351095978680135899492248257695041017356054593190955520327021115464586928546427690916935663560250217906547214215111980791471418512687315406032483042703942888921516391465991351725532875116042201159123491077225188333785543728665699321222852256855486016902799161554419706203116242011790324372944301257/283888830740391700589904886800108748800000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "45956159174072599700841582644791226032878246665742377989239619323538481272388953891440180540388088742240770468280378465547661315735639618338871905743947692214814650360642126032855980654654145165140979341381631384417499442391959619139907958463895595691812487237603699748796032510207380134546694746086937496955809382451/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": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 74655, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "strict_power_of_two": 269, + "witness": { + "cut": 73467, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 73467, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 74655, + "lifetimes": 58, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 64552, + "CLEAR": 58, + "COPY": 1, + "INIT": 58, + "MOVE": 6274, + "SCALE": 3712 + }, + "owned_labels": 55, + "peak_owned": 44, + "public": 1494, + "scalars": { + "dyadic": 62829, + "integer": 39381, + "noninteger": 28884, + "odd": 5436 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 15457904, + "dyadic_height": 25, + "mass_witness": [ + 65243, + "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": [ + "1137910159590527531413131790759846713229394980448286617625862630822886101377253/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "2275820319181055062826263581519693426458789960896573235251725261645772212162691/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003642574878947", + "gain": "2.19812527E-7", + "gain_exact": "219812527/1000000000000000", + "independent_raw_bracket": [ + "0.00364257487894748489413669208358703", + "0.00364257487894748489413669208358704" + ], + "previous_claim": "182117753321/50000000000000", + "raw_bracket": [ + "0.003642574878947484894136692083587", + "0.0036425748789474848941366920835871" + ] + }, + "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": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f" + }, + "source_head": "a95783a8c861248a759136d4285ea725499cf231", + "status": "PASS_P104_TEMPORAL_CHART120_NATIVE", + "word_canonical_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f" +} diff --git a/research/p104-temporal-chart120-split/NOTICE b/research/p104-temporal-chart120-split/NOTICE new file mode 100644 index 0000000000..1c2fdc9f03 --- /dev/null +++ b/research/p104-temporal-chart120-split/NOTICE @@ -0,0 +1,11 @@ +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 + +This successor retains #7140 construct.py, certificate.py, support.py and split.py byte-identically. ToikY's earlier chart120 lead remains credited through #7120; the new temporal certificate is on exact #7140. diff --git a/research/p104-temporal-chart120-split/PATHS.json b/research/p104-temporal-chart120-split/PATHS.json new file mode 100644 index 0000000000..a20ba0c1b5 --- /dev/null +++ b/research/p104-temporal-chart120-split/PATHS.json @@ -0,0 +1,93 @@ +[ + { + "role": 649, + "lo": 39225, + "hi": 39227, + "frame": 120, + "moves": [ + 39226 + ], + "frames": [ + 3, + 120 + ] + }, + { + "role": 650, + "lo": 39279, + "hi": 39280, + "frame": 120, + "moves": [ + 39279 + ], + "frames": [ + 120, + 852 + ] + }, + { + "role": 651, + "lo": 39294, + "hi": 41470, + "frame": 120, + "moves": [ + 41469 + ], + "frames": [ + 120, + 853 + ] + }, + { + "role": 1305, + "lo": 39293, + "hi": 39298, + "frame": 120, + "moves": [ + 39297 + ], + "frames": [ + 120, + 856 + ] + }, + { + "role": 1449, + "lo": 39224, + "hi": 39227, + "frame": 120, + "moves": [ + 39225 + ], + "frames": [ + 3, + 120 + ] + }, + { + "role": 1449, + "lo": 39288, + "hi": 41465, + "frame": 120, + "moves": [ + 41464 + ], + "frames": [ + 120, + 850 + ] + }, + { + "role": 1488, + "lo": 39294, + "hi": 40403, + "frame": 120, + "moves": [ + 40402 + ], + "frames": [ + 120, + 850 + ] + } +] diff --git a/research/p104-temporal-chart120-split/PROOF.md b/research/p104-temporal-chart120-split/PROOF.md new file mode 100644 index 0000000000..201e84e7ad --- /dev/null +++ b/research/p104-temporal-chart120-split/PROOF.md @@ -0,0 +1,132 @@ +# A second fully charged causal-history split, at chart 120 + +This is one source-bound instance of Ali Romman's causal-history owned-buffer +mechanism. It uses the byte-identical constructor and timed-certificate checker +from #7140, with a new source, witness, path, inventory and complete application. +It is a conditional finite construction, not a complete multiplication theorem. + +## Exact source and coefficient identities + +`INPUTS.json` retains all 30 files from #7140 at +`a95783a8c861248a759136d4285ea725499cf231`, package +`research/p104-causal-buffer-split`, including its full nested closure and notices. +The exact source word has SHA256 +`81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea`. +The new word has SHA256 +`c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f`. + +Let P(t,r) be the complete normalized-coordinate source row immediately before +original event t, and S(t,r) the complete final response to adding one unit to +role r there. Owned initialization, erasure and COPY are included in these +linear maps. The independently reconstructed certificate is + +``` +P(39225,649) + P(39224,1449) = e1449 = c +``` + +and + +``` +−S(39280,650)/2 − S(39298,1305)/2 − S(40403,1488)/2 ++ S(41465,1449) − S(41470,651)/2 + S(41668,198) = e1449 = d. +``` + +These are equalities in every source public input/output coordinate, not just +the displayed coordinate. In particular, all main inputs, old #7140 added +public input, retired helper and other boundary groups cancel. Thus `c d = 1`. +The common helper group has boundaries U=3 (zero space), V=127 (full space). +Frame F=120 has basis [7,25,75,160,288] and dimension five. + +## Legal temporal access and the paid change + +`PATHS.json` gives seven original MOVE paths. They are retimed only between +adjacent scalar contacts: the constructor checks that every role event in each +interval is one of the declared MOVEs and that no other operation reads it. +Their paths and paid ranks are retained. This brings the two collection roles +to F before their respective gathers and leaves each delivery role there until +its injection. Pivot p=648 already resides at F at retirement cut 39225. + +The one changed paid path is main role 198 in interval [41607,41668]. Original +MOVE 41667 goes from frame 597, basis [82], to frame 207, basis +[2,5,8,17,33,65,129,257], rank seven. Replace it by 597→120 at cut 41607 and +120→207 at cut 41668. The exact inclusions are checked; these ranks are four +and three. The injection at 41668 occurs before departure. No other source +contact moves across a read or write. + +The seven neutral paths and this one paid path are all source-bound. Each +gather/injection is checked against its actual frame after retiming. Scalar +coefficients and roles outside the explicit split remain those of the source, +with the required successor and owned-label relabeling. + +## The two-buffer identity + +Take p=648 and the fresh arbitrary public input n=1493 at F, value z. The helper +boundary matrix G is simply the swap of roles 648 and 1449: its row p is c and +`G d=e_p`. The credited elementary basis algorithm emits four instructions for +G, with only unit coefficients. Apply G inverse at U. The gathered functional +c then equals the original independent input x_p. + +Initialize owned A at F before the first gather. At cut 39225, A=x_p and the +current value of p is some v. Initialize owned B=0 and execute + +``` +B += n; B -= A; +n += p; n -= A; n -= B; +p += A; p -= n. +``` + +The result is B=z−x_p, n=v and p=x_p. Clear A under the inherited owned-erasure +contract; retire p at F. Continue every old p occurrence on n instead, shifting +all old owned labels by one. At the six declared later cuts, add the listed +coefficient times B to the designated role in F. Their full final response is +`d(z−x_p)`. Clear B after the last injection. + +Finish with G at V, using n as the successor of p. The source helper map is the +identity, and G maps the added response to `e_p(z−x_p)`. Thus n returns z; retired +p already holds x_p; all other public outputs and the full main operator are +unchanged. All owned rows are cleared. Both complete operator directions are +also checked by separate exact executions. + +The two buffers are explicit owned storage. Neither arbitrary public input is +initialized or discarded. This argument does not require an invertible local +map on public cut coordinates, a simultaneous middle pairing, or an additional +opcode. It does not claim that two buffers are minimal. + +## Accounting and scope + +The new native delta is ΔP={3:+1,4:+1,7:−1} and ΔT={4:+1,5:+1,9:−1}. Both rank +masses are unchanged. There are 1,494 public fields and 1,094 helpers, 55 owned +labels and 58 owned lifetimes. Peak owned stock stays 44; owned rise mass stays +56. The 74,655 instructions add 21 ADDs, two SCALEs, one MOVE, two INITs and two +CLEARs. All extra lifetimes and scalar services are charged. + +The unchanged 17-stage caller has 110,434 paid positions, 22,342 productive +fields, surplus 1,424 and zero empty-root credit. Both directed price engines +nominate κ=.003643180671645, an increase of .000000221652614 over #7140. +`APPLICATION.md` and `VALIDATION.md` record the actual full replay and its +status; the coefficient identity alone does not establish those checks. + +The freshly derived grid remains 1125/F25. Exact lifecycle adapters bind +(lifetimes, peak, labels) to (58,44,55) in both precision paths. They retain the +lifecycle assertion and reject an extra uncharged lifetime. No frozen source +bytes are edited. All caller storage, grid, envelopes, ordinary and compiler +costs are recomputed for this word. + +The search stopped at its first positive after 715 of 7,667 individually +affordable paths. This is not a temporal optimum or an exclusion of remaining +paths. Earlier ToikY chart-120 work is retained through the predecessor chain; +this package does not claim discovery of the chart. Credit Ali Romman, +CubeJerry, Matarener, Rohan Arun, ToikY and all retained authors. + +## Open next questions + +1. Independently replay the two simple boundary-vector equations, all typed + observation times, and the complete new storage/caller application. +2. After a fresh upstream/overlap checkpoint, test an uncovered causal domain + on this changed source, with every path and owned cost included. + +The five inherited framework assumptions remain: native_all_columns, +owned_erasure, compiler, precision_tape and analytic_recovery. Human/formal +acceptance, maintainer admission and compiled top-level execution remain open. +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. diff --git a/research/p104-temporal-chart120-split/README.md b/research/p104-temporal-chart120-split/README.md new file mode 100644 index 0000000000..f4e6e59138 --- /dev/null +++ b/research/p104-temporal-chart120-split/README.md @@ -0,0 +1,111 @@ +# Conditional κ = 0.003643180671645 from a temporal split at chart 120 + +This source-bound candidate improves the complete signed P104 invoice over +[#7140](https://github.com/CrocSwap/integer-mult-bounds/pull/7140) by +**0.000000221652614**, from κ=.003642959019031 to **κ=.003643180671645**. +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. + +Two values collected at different times in frame 120 isolate helper input +1449. Two explicitly initialized owned buffers let pivot 648 retire there while +a fresh arbitrary public input continues its old program. Six later injections +restore the complete output direction. One paid path changes from rank seven +to ranks four and three, funding a productive split from rank nine to five and +four. This is another instance of **Ali Romman's causal-history owned-buffer +mechanism**; [PROOF.md](PROOF.md) states its exact chronology and identity. +ToikY's earlier chart-120 lead is credited through the predecessor chain. + +| Count | Source | Candidate | +|---|---:|---:| +|Native public fields|1493|1494| +|Native independent helpers|1093|1094| +|Owned labels|53|55| +|Owned lifetimes|56|58| +|Peak simultaneous owned fields|44|44| +|Native instructions|74627|74655| +|Complete paid positions|110417|110434| +|Complete productive fields|22325|22342| +|Rank surplus|1424|1424| +|Empty credit|0|0| + +The exact per-native changes are ΔP={3:+1,4:+1,7:−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 21 more ADDs, two SCALEs, +one MOVE, two INITs and two CLEARs. The fresh minimal grid remains **1125/F25**. +The two directed price engines bracket the emitted invoice's crossing in + +``` +(0.0036431806716457592014331762194701, + 0.0036431806716457592014331762194702). +``` + +This is an invoice-specific ceiling, not an optimum over temporal programs. +The retained BIT cap .00376669 leaves .000123509328355 headroom above the claim. +The original one-path search stopped at its first positive after 715 of 7,667 +individually affordable paths; it does not exclude the unvisited domain. + +## Exact inputs and reproduction + +`INPUTS.json` authenticates the complete 30-file #7140 package at +`a95783a8c861248a759136d4285ea725499cf231`, including every nested source and +notice. `REUSE.json` binds six byte-identical implementation files to that +source. All three registered commands check this reuse before computation. + +Source native SHA256: +`81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea`. +Candidate native SHA256: +`c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f`. +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-temporal-chart120-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,038 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. + + +## Concurrent work + +The 00:21 UTC overlap refresh found Rohan Arun's draft +[#7142](https://github.com/CrocSwap/integer-mult-bounds/pull/7142), exact head +`d446d891ab4c25b3a7df002ae3a9d140b492bfab`, with provisional κ=.003643216822476 +on the same #7140 source. Its endpoint-funded change is distinct, with native +ΔT={2:+1,7:+1,8:−1}, ΔP={1:+1}; its full verification was still pending. +This package improves #7140 and supplies a separate temporal instance. It does +not claim to beat #7142, validate that draft, or establish composability. +A future composition must reconstruct and reprice the complete combined word. + +## 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-temporal-chart120-split/REPLAY.txt b/research/p104-temporal-chart120-split/REPLAY.txt new file mode 100644 index 0000000000..4aff59b619 --- /dev/null +++ b/research/p104-temporal-chart120-split/REPLAY.txt @@ -0,0 +1,75 @@ +CHECK Authenticate complete 30-file #7140 export and nested closure; reconstruct two timed prefix rows, six suffix columns and c=d=e1449; exact paths, unit pairing, full candidate and ten controls; compare every certificate field. +PASS_EXACT_TIMED_OBSERVATIONS +CHECK Reconstruct complete source/candidate; whole forward/adjoint, inventory/deltas and exact 58/44/55 lifecycle; independent 1125/F25 grids; ingredient cost/precision, six 512-column chart/phase checks, 18 native controls and finite physical routes; every frozen 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 74655 public 1494 owned roles 55 paid {1: 3994, 2: 854, 3: 828, 4: 225, 5: 342, 6: 15, 7: 10, 8: 6} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 16, 2: 20, 3: 47, 4: 220, 5: 76, 6: 43, 7: 18, 8: 35, 9: 619} +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 74655 events, 2953 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1094), 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_TEMPORAL_CHART120_NATIVE 3642574878947/1000000000000000 +CHECK Full unchanged 17-stage caller; all 3038 paid/helper maps and 104 main boundaries; fresh ordinary/owned-stock/physical/grid/envelope/compiler costs, both prices and 54+4 outer conditions; every application field. +PASS two reconstructed invoices and both exact price engines 0.003643180671645 +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 ['36431806716457592014331762194701/10000000000000000000000000000000000', '18215903358228796007165881097351/5000000000000000000000000000000000'] +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 110434 13600 22342 +RUN check_odd_precision.py +PASS short precision 406 1181 2362 +RUN check_odd_partial_admission.py +ordinary bill 779260044 +PASS partial signed short gates 779260044 728636134329/200000000000000 {'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 42835744 25442777600 precision 2362 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3038 +PASS complete 8+9 component application checks 728636134329/200000000000000 3038 110434 +PASS_P104_TEMPORAL_CHART120_SPLIT 728636134329/200000000000000 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-temporal-chart120-split outcome=partial diff --git a/research/p104-temporal-chart120-split/RESULT.json b/research/p104-temporal-chart120-split/RESULT.json new file mode 100644 index 0000000000..e559bf1eee --- /dev/null +++ b/research/p104-temporal-chart120-split/RESULT.json @@ -0,0 +1,1566 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "8f8f45c2bae2ae4469b738ba3d8e6b066c5110a81f7fb5c4b50b70dc946c36de", + "check_odd_precision.py": "90ed451efc7e09708df84cab704f6e1b39c461890e3f76215b92f6883b064b43", + "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(\".003643180671645\")", + "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) == (58, 44, 55)')\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": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "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": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + }, + { + "catalogue_digest": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "exact_recipe_digest": "6b82845b3513edc6689dc9b69a1860c920502b9894ffcdb37a5869b39593ba2a", + "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": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + }, + { + "catalogue_digest": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1038, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "exact_recipe_digest": "d0fc6a8f244feb7af1eff8bfebab8f6492a42a625e85d8573a340f93b6223a5b", + "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": 3038, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "728636134329/200000000000000", + "catalogue": [ + { + "catalogue_digest": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "exact_recipe_digest": "b9cdcbe051edca0b1fb57ede0bc0ba3c8614a4586d18b8946141fc9030ca731e", + "log_sha256": "f7eb83bbef0b145f2fcbad236f87a3369282cbd6734fcf8790b3dcfcedef1623", + "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": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + }, + { + "catalogue_digest": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "exact_recipe_digest": "6b82845b3513edc6689dc9b69a1860c920502b9894ffcdb37a5869b39593ba2a", + "log_sha256": "dd5da05a84c9d1791dbfa150d7bc91a6a46c391670f22edde6be5709bcdc06a2", + "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": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + }, + { + "catalogue_digest": "2234c12e1295b3c3f0ee0a5b7f4046683225f000bac684712c13e610656afe8d", + "catalogue_size": 3038, + "checked_maps": 1038, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2953, + "exact_recipe_digest": "d0fc6a8f244feb7af1eff8bfebab8f6492a42a625e85d8573a340f93b6223a5b", + "log_sha256": "46964d3df2588295c70a1bb5d413ee410cb7af7abfb739fa575faa367b8e1b27", + "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": 3038, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f" + } + ], + "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": 25442777600, + "log_power": 2236, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298400, + "native_invocations": 17, + "native_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "owned_banks_per_raw_occurrence": 935, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58284, + "native": 1162477 + }, + "scalar_services_upper": 42835744, + "scalar_steps_coefficient": 44916533100544, + "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": "728636134329/200000000000000" + }, + "native_archive_sha256": "775717cdc81477a83e7dc92efecc7168fd7b8c1c94903155845bbb7877954e4f", + "native_canonical_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "numeric_gate": { + "BIT_margin": "12350932835493/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "728636134329/200000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9033392097237479, + 0.9033392097237479 + ], + "derivative_upper": -381869.482977855, + "gamma": [ + 0.9408446849887456, + 0.9408446849887456 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364318067164507/100000000000000000": [ + "15537541084201418881496468482102120599885753440278632498994792625265464899363/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "15537541084201418881496468482102120599885753440278632498994792625265464899609/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "728636134329/200000000000000": [ + "12430032867360906459425864480349490259675106222589073827059408810730807817881/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124300328673609064594258644803494902596751062225890738270594088107308078180799/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + -1.1220401731763849e-30, + -1.1220401731763849e-30 + ], + "364318067164507/100000000000000000": [ + 2.6737376222940476e-10, + 2.6737376222940476e-10 + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + 3.7672679245382997e-29, + 3.7672679245382997e-29 + ] + }, + "moment_margins": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + "-112204017317638486010032192049322752217298134836987/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-14025502164704810751254024006165344027162262021843/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364318067164507/100000000000000000": [ + "5347475244588095446690626246834102848838767824956951845609491954220713/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "13368688111470238616726565617085257122096919562392379614023729904860409/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + "376726792453829994330939723599154416320699357729931/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1883633962269149971654698617995772081603496808085517/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36431806716457592014331762194701/10000000000000000000000000000000000", + "18215903358228796007165881097351/5000000000000000000000000000000000" + ], + "tested": "364318067164507/100000000000000000", + "written_log_power": 2236 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "2071e38f171b1844b98f7d61a88767d260a799a189c14ab43e6df61b801e9732", + "fresh_helpers": 18598, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1494, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14076, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 170, + "8": 758, + "9": 32 + }, + "paid_positions": 110434, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22342, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 935, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3740, + "41": 416, + "49": 416, + "5": 1292, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10939 + } + }, + "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": 779260044, + "init_clear_allowance": 232, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 220739956, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2641392, + "raw_upper": 762610492, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2188, + "moves": 6274, + "owned_lifetime": 232, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9894000, + "scalar_upper": 2069068 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12350932835493/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "728636134329/200000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9033392097237479, + 0.9033392097237479 + ], + "derivative_upper": -381869.482977855, + "gamma": [ + 0.9408446849887456, + 0.9408446849887456 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364318067164507/100000000000000000": [ + "15537541084201418881496468482102120599885753440278632498994792625265464899363/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "15537541084201418881496468482102120599885753440278632498994792625265464899609/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "728636134329/200000000000000": [ + "12430032867360906459425864480349490259675106222589073827059408810730807817881/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124300328673609064594258644803494902596751062225890738270594088107308078180799/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + -1.1220401731763849e-30, + -1.1220401731763849e-30 + ], + "364318067164507/100000000000000000": [ + 2.6737376222940476e-10, + 2.6737376222940476e-10 + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + 3.7672679245382997e-29, + 3.7672679245382997e-29 + ] + }, + "moment_margins": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + "-112204017317638486010032192049322752217298134836987/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-14025502164704810751254024006165344027162262021843/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364318067164507/100000000000000000": [ + "5347475244588095446690626246834102848838767824956951845609491954220713/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "13368688111470238616726565617085257122096919562392379614023729904860409/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + "376726792453829994330939723599154416320699357729931/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1883633962269149971654698617995772081603496808085517/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36431806716457592014331762194701/10000000000000000000000000000000000", + "18215903358228796007165881097351/5000000000000000000000000000000000" + ], + "tested": "364318067164507/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": 14076, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 170, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3740, + "41": 416, + "49": 416, + "5": 1292, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10939 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036431806716457592014331762194701971077502557226870537927742832114", + "raw_crossing": "0.0036431806716457592014331762194701971077502557226870537927742832114" + }, + "native_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "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": 779260044, + "init_clear_allowance": 232, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 220739956, + "odd_divisions": { + "ADD": 5365, + "SCALE": 71 + }, + "per_input_conversion": 2641392, + "raw_upper": 762610492, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2188, + "moves": 6274, + "owned_lifetime": 232, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9894000, + "scalar_upper": 2069068 + }, + "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": 25442777600, + "log_power": 2236, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298400, + "native_invocations": 17, + "native_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "owned_banks_per_raw_occurrence": 935, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58284, + "native": 1162477 + }, + "scalar_services_upper": 42835744, + "scalar_steps_coefficient": 44916533100544, + "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": "728636134329/200000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "2071e38f171b1844b98f7d61a88767d260a799a189c14ab43e6df61b801e9732", + "fresh_helpers": 18598, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1494, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14076, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 170, + "8": 758, + "9": 32 + }, + "paid_positions": 110434, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22342, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 935, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3740, + "41": 416, + "49": 416, + "5": 1292, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10939 + } + }, + "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": 15457904, + "dyadic_height": 25, + "mass_witness": [ + 65243, + "stored add" + ], + "maximum_scaled_mass": "814448574117075/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "precision_program_sha256": "ff907507ab16918785debc2f6dccfbe785d2c75517d4d0a756bfc4381e3fb929", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "5950784623182845790996176145840141972606356023840996739829187421212069506940119080672409697234473521460020002951814642793868017817309717171386204628616913415737281937695698172386816093640100740707730854554784106458745243241605009912419438212742986437205600434663088286701749386343076207360847895288387236346536152144259780480961015679814493535356191990749300056873190763168337935817742493694935217615423239648820256365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "strict_power_of_two": 1148, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "153575481938414420628508914501089416303551490872808724411946813028975592888169910578066612803762003464741312352240249873236501457838673838528917172314512188886031462778478023745921626131831999994505353524281079562835142551307753110654491610819022465291415372759425832132078258038529419675765602171644143706454334174097971430282130775698760434487988673679143015241424279481162947700308797952212339954037025655083340946372048137337/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": "24898013888921000947988754918930424986310464865347860187623451924252059353682805919842551032312688980719215446108729257185876782667776881515557210689136513497406992221403623410781982291989519813458476082973576845821552197757590411962295867527791554478931217875671231734541429477482350946362240635079604691827418650586999184598677487843723211605492560624945505088221550022541060878884022511184069547676277766001510234745646089593237/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": "153575481938414420628508914501089416303551490872808724411946813028975592888169910578066612803762003464741312352240249873236501457838673838528917172314512188886031462778478023745921626131831999994505353524281079562835142551307753110654491610819022465291415372759425832132078258038529419675765602171644143706454334174097971430282130775698760434487988673679143015241424279481162947700308797952212339954037025655083340946372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1153, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "11903953213184369444000145991168543865672324212312134721430299759483567844090048460027559269485817431834264431069483856453340970389879163164372920066458178754794552983577541282966130899505682738064899702104361152945448519480429755263865522370913189181997562330201357253956879799480033429226525643540137841928993323414211334175032779850860964250126667371376697057879550863484245488931068471536190697224603570991035559980509985432880574130034236513213148464818801579919535159802898936434565656326518086864515768479494442270916486386512558312217000411125141591094009/7011716485308428615133405458301579549733503737764404511774644319027200000000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1416, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18598, + "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": "5950784623182845790996176145840141972606356023840996739829187421212069506940119080672409697234473521460020002951814642793868017817309717171386204628616913415737281937695698172386816093640100740707730854554784106458745243241605009912419438212742986437205600434663088286701749386343076207360847895288387236346536152144259780480961015679814493535356191990749300056873190763168337935817742493694935217615423239648820256365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808724411946813028975592888169910578066612803762003464741312352240249873236501457838673838528917172314512188886031462778478023745921626131831999994505353524281079562835142551307753110654491610819022465291415372759425832132078258038529419675765602171644143706454334174097971430282130775698760434487988673679143015241424279481162947700308797952212339954037025655083340946372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808724411946813028975592888169910578066612803762003464741312352240249873236501457838673838528917172314512188886031462778478023745921626131831999994505353524281079562835142551307753110654491610819022465291415372759425832132078258038529419675765602171644143706454334174097971430282130775698760434487986776810482605948447285231957125441108797952212339954037025655083340946372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "5950784623182845790996176145840141972606356023840996739829187421212069506940119080672409697234473521460020002951814642793868017817309717171386204628616913415737281937695698172386816093640100740707730854554784106458745243241605009912419438212742986437205600434663088286701749386343076207360847895288387236346536152144259780480961015679814493535356191990749300056873190763168337935817742493694935217615423239648820256365157210347/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "153575481938414420628508914501089416303551490872808724411946813028975592888169910578066612803762003464741312352240249873236501457838673838528917172314512188886031462778478023745921626131831999994505353524281079562835142551307753110654491610819022465291415372759425832132078258038529419675765602171644143706454334174097971430282130775698760434487988673679143015241424279481162947700308797952212339954037025655083340946372048137337/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "70781794236287195030348250068208882768064586700726902597094028684303155678494643063955415415192049911011451320724790286355374549834337395117/54147497318342533224087693557760000000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "107545294043015029201756409382013557124342398052652427105989167303298308126268511441795079319346782288162697855010149145664729645800947045348878033745197/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "100168175869035538583454700175395892596545528809091594736317385291140549485951901542671081816953774248407454279032305847286599460840734450019642426763265911827821/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "20462096215773093331938345895919888649659971619199158930440511507792625824603218624914764464838708702447983390271541571116334680527956537105283196733845184464718833792976891/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "1959245396486567172679556992644997486924117030619319936008602207778977807568917763647735065110444423614243926188392635053113362687294159028798155056686630444092488978645343604179477119/77972396138413247842686278723174400000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "208963523432934541384374238529763317306985995543556420854912390403043140065533441695767218919572365455856722384007180165429414426938943138023504037653164768584700845552146870284738682849501969969/8663599570934805315854030969241600000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "60841691818156516717396102157656697660676542114685715284506225506994934320406122768525525088289297137567557613598311292780650337289163855763613404711948334844695063301112898756873703861520609248732190667544673351/9746549517301655980335784840396800000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "21697531926071343710752970255685586859141744555390432948602334219653678221792683563798149567708695480154690421401242416561392722593627069540611120266197646101588934280225142092585033522154494560296287934463559039663703875373162052257325944149523566642365087267237833853183321295405883261720813790939895217716271147539515674990043922872422444335971/11240703172795810234039995293761536000000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "8250516653555791125890881867522338849450120456649681753710581127825127695506740120260194395040726654499897236519659396580322503411994963304784648265351034113618241194943631033179057751580039234253012377056373128253391022920058617828023211351720806907527615305705787861099708856504953936248019044544209890800897504219955676376430901243431004546631501382745847409/281017579319895255850999882344038400000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "3936204376350553959586383346644828166594520899380441345945512943922670793583859918175205024185759617398886162153435046741181681201086705237752531082987430889854619562557581723073844311378473688210760900947720383870494062174103269460397240198709320435266881502967143570009123566582424841269007706428564643783071090261706044896512013547452700229034986985022684495998821374571/9367252643996508528366662744801280000000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "49463970025121248366518699401031308310261171873816535375759590742092975586524853540180910691065488189376002102904344499210318682273501631438718871870876699624031120434269948837365418092832925809959225152502521412459883731850600188114292049888199478890859306094397722264832486858363397859799033202416415844840468021467544339826997864016732867572419216967869317904822466644551551426123467/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "3258160231781066034828529159079569045220708622412000712710082721214524398625490437526686081825939439123911240850732034323623330564296286284990021000250941897427160696657524603779125946371488321570091120711800331954719150153397521449398933114627828862448397680673788811124083583089537315105329238141419730637221898256908678587589216457443034164937296857356055895185787261023013584557453994867723/316144776734882162832374867637043200000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "130852841430007986947925306965587083830118455280871509399081801060031340879124906047503129643817995600075391389182874910631756857548580915481982217919585496551592459158456262715086961061920251830087711696017032029561331833462318116733702804687928381714505844460363589089385595261803175809484067387244354891528444983632534572593266037033383281625522131695775585389827936757907160472184363419466103783365187/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "2500880907037703392526195614784754002174462781117045491406170699050459161332682530400733538175582764906506460840734590965376399619878401944431090587137712767797463754664539225628476543596531212048542194631803659317910924030293605431696227859132932883909703524054911792623480817216266048077703448165526738590860496891676564857040089807783028580682183385365381562032784582949860708254576402381447407911628434702977/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "2768451246231694624969698856577357156018386083041536848140559208576494868693930677544209827445622548631266788289583237889593779971104666583166010249313516317907596285065340722573857054279484339653378782925616636436553248604092358009717544263943130756517056004911958869605121754443859943117711510661644371559648075007731526104910874464641513722915391819985733869940613301516994053765220449375441290396883178661222764040091/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "5950784623182845790996176145840141972606356023840996739829187421212069506940119080672409697234473521460020002951814642793868017817309717171386204628616913415737281937695698172386816093640100740707730854554784106458745243241605009912419438212742986437205600434663088286701749386343076207360847895288387236346536152144259780480961015679814493535356191990749300056873190763168337935817742493694935217615423239648820256365157210347/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": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 74655, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "strict_power_of_two": 269, + "witness": { + "cut": 73467, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 268, + "witness": { + "cut": 73467, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 74655, + "lifetimes": 58, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 64552, + "CLEAR": 58, + "COPY": 1, + "INIT": 58, + "MOVE": 6274, + "SCALE": 3712 + }, + "owned_labels": 55, + "peak_owned": 44, + "public": 1494, + "scalars": { + "dyadic": 62829, + "integer": 39381, + "noninteger": 28884, + "odd": 5436 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26507, + "entrance_mass": "2000400613863487932765843643656219553416122803290482515127829655412769816972356841682229988383242659879694282215447485007608789588159147/2772351862699137701073289910157312000000000000000000000", + "residual_mass": "41262390928967408335367787392851307455352920152900683392975561300789349512095048315750930520336313548400274178998929423953251065102531/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": 14076, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 170, + "8": 758, + "9": 32 + }, + "raw_bracket": [ + "36431806716457592014331762194701/10000000000000000000000000000000000", + "18215903358228796007165881097351/5000000000000000000000000000000000" + ], + "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": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "target": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3740, + "41": 416, + "49": 416, + "5": 1292, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10939 + } + } + }, + "claim": "728636134329/200000000000000", + "price": { + "after": { + "P": { + "1": 68282, + "16": 416, + "2": 14518, + "24": 416, + "3": 14076, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5814, + "56": 416, + "6": 255, + "64": 208, + "7": 170, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 340, + "25": 416, + "3": 799, + "33": 416, + "4": 3740, + "41": 416, + "49": 416, + "5": 1292, + "57": 416, + "6": 731, + "65": 416, + "7": 306, + "73": 208, + "8": 595, + "9": 10939 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036431806716457592014331762194701971077502557226870537927742832114", + "raw_crossing": "0.0036431806716457592014331762194701971077502557226870537927742832114" + }, + "before": { + "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" + }, + "gate": { + "BIT_margin": "12350932835493/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16502900000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "728636134329/200000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9033392097237479, + 0.9033392097237479 + ], + "derivative_upper": -381869.482977855, + "gamma": [ + 0.9408446849887456, + 0.9408446849887456 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364318067164507/100000000000000000": [ + "15537541084201418881496468482102120599885753440278632498994792625265464899363/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "15537541084201418881496468482102120599885753440278632498994792625265464899609/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "728636134329/200000000000000": [ + "12430032867360906459425864480349490259675106222589073827059408810730807817881/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124300328673609064594258644803494902596751062225890738270594088107308078180799/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2235, + "moment_margin_float": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + -1.1220401731763849e-30, + -1.1220401731763849e-30 + ], + "364318067164507/100000000000000000": [ + 2.6737376222940476e-10, + 2.6737376222940476e-10 + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + 3.7672679245382997e-29, + 3.7672679245382997e-29 + ] + }, + "moment_margins": { + "18215903358228796007165881097351/5000000000000000000000000000000000": [ + "-112204017317638486010032192049322752217298134836987/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-14025502164704810751254024006165344027162262021843/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364318067164507/100000000000000000": [ + "5347475244588095446690626246834102848838767824956951845609491954220713/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "13368688111470238616726565617085257122096919562392379614023729904860409/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36431806716457592014331762194701/10000000000000000000000000000000000": [ + "376726792453829994330939723599154416320699357729931/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1883633962269149971654698617995772081603496808085517/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36431806716457592014331762194701/10000000000000000000000000000000000", + "18215903358228796007165881097351/5000000000000000000000000000000000" + ], + "tested": "364318067164507/100000000000000000", + "written_log_power": 2236 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "c38b79279f665d46d795501de6645a8a16d9324c22199fa615313b6abfdc3e2f", + "old_native": "81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "8598954902761366908066441159740651732728054113577591864794638076613900228663179/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "8598954902761366908066441159740651732728054113577591864794638076613900263379013/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003643180671645", + "gain": "2.21652614E-7", + "gain_exact": "110826307/500000000000000", + "independent_raw_bracket": [ + "0.00364318067164575920143317621947019", + "0.0036431806716457592014331762194702" + ], + "previous_claim": "3642959019031/1000000000000000", + "raw_bracket": [ + "0.0036431806716457592014331762194701", + "0.0036431806716457592014331762194702" + ] + } + }, + "status": "PASS_P104_TEMPORAL_CHART120_SPLIT" +} diff --git a/research/p104-temporal-chart120-split/REUSE.json b/research/p104-temporal-chart120-split/REUSE.json new file mode 100644 index 0000000000..d03c9bf6fc --- /dev/null +++ b/research/p104-temporal-chart120-split/REUSE.json @@ -0,0 +1,36 @@ +{ + "head": "a95783a8c861248a759136d4285ea725499cf231", + "files": [ + { + "path": "construct.py", + "source_path": "research/p104-causal-buffer-split/construct.py", + "sha256": "2e07135e9c733bd0a6d61eb1d9c2bfbf5b482f599dcb6f82238e15ee9bd93018" + }, + { + "path": "certificate.py", + "source_path": "research/p104-causal-buffer-split/certificate.py", + "sha256": "15581732d5e07550a2fea1dcb17a1eb106a053ef69223c4c861d4e322149ce86" + }, + { + "path": "support.py", + "source_path": "research/p104-causal-buffer-split/support.py", + "sha256": "f3e6eeb879480715c5c32c1a390a63c57d26ea1c9a9cbdb89b83ca34260e47f6" + }, + { + "path": "split.py", + "source_path": "research/p104-causal-buffer-split/split.py", + "sha256": "999b9eeabe5cd1a7e3ec014d1a449f850b4ac9bfb19749cddef41ae12cd0b405" + }, + { + "path": "verify_certificate.py", + "source_path": "research/p104-causal-buffer-split/verify_certificate.py", + "sha256": "0c79decfe1c0286e2aea72706579ccdd480dee8c31a50bda80bc52e44d1ea478" + }, + { + "path": "derive_grid.py", + "source_path": "research/p104-causal-buffer-split/derive_grid.py", + "sha256": "ceb7a44ef19d72a16db7b43c65c85910d965499d1715436011de32af5d39dbb0" + } + ], + "scope": "Byte-identical credited implementations; full source and every changed witness/cost are checked separately" +} diff --git a/research/p104-temporal-chart120-split/SOURCES.json b/research/p104-temporal-chart120-split/SOURCES.json new file mode 100644 index 0000000000..c4150ae397 --- /dev/null +++ b/research/p104-temporal-chart120-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-temporal-chart120-split/TASK.json b/research/p104-temporal-chart120-split/TASK.json new file mode 100644 index 0000000000..9f7bf7fd87 --- /dev/null +++ b/research/p104-temporal-chart120-split/TASK.json @@ -0,0 +1,139 @@ +{ + "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": "Continue the credited causal-history mechanism on the changed, fully verified #7140 source. This instance uses c=d=e1449, frame120 and one charged main198 path; every new owned lifetime and caller cost is recomputed.", + "concrete_question": "Can the exact source7140 history isolate helper1449 and retire pivot648 at frame120 using one paid rank7\u21924+3 path?", + "actual_scope": "Source7140, frame120/cut39225/pivot648; two gathers and six injections; two new stationary owned buffers, seven neutral path intervals and one paid path. Full native and signed17-stage application.", + "domain": "One exact causal certificate and deterministic constructor on changed source7140. Search stops at first positive after715 of7667 individually affordable paths; remaining paths are unprocessed.", + "success": "A full changed-invoice application with kappa > .003642959019031.", + "bottleneck_link": "A simple boundary direction becomes available through separate observation times. One paid path is cheaper than the productive rank9 split; all storage and scalar completion remains charged.", + "predecessor_head": "a95783a8c861248a759136d4285ea725499cf231", + "predecessors": [ + "dillona/OpenAI Codex #7140 exacta95783a8c861248a759136d4285ea725499cf231, complete30-file export with full source closure; constructor, timed checker and helper algorithms retained byte-identically.", + "Ali Romman: causal-history owned-buffer identity, helper bases and paid meetings.", + "CubeJerry: temporal history spaces, contact-free retiming, exact native/caller/precision/compiler methods.", + "Matarener: complete helper kernels.", + "Rohan Arun: #7122/#7124 recharting and #7113 signed17-stage caller.", + "ToikY: earlier chart120 lead, retained through #7120; this package does not claim discovery of the chart.", + "Cinna Davis/1337isnot1337, Dugongue, DreamingOfClouds, Douglas Colkitt/#7000 reviewers, and every retained nested source author.", + "Concurrent Rohan Arun #7142 endpoint-funded split: distinct higher early price, not included or replayed here; possible composition remains open." + ], + "outcome": "completed", + "evidence_status": "All three direct CPython 3.14.7 and registered isolated CPython 3.12.16 commands passed; every frozen certificate/native/application field matched; 24 scientific hashes unchanged. Full native/caller/physical/cost/precision, six sets of 512 native chart columns, all 3038 paid/helper maps and 104 main boundaries, 18 native controls 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": "Canonical e54523517d0f03e58352e647c403a5af3e525a57 refetched unchanged at 00:20 UTC; revision 8 / selected #7000 unchanged. Complete snapshot: 442 open PRs at 00:21:17 UTC and 7055 Discussion records at 00:22:18 UTC. Sparse local coverage: 12 working records, 10178 HEAD note paths, 10167 unsearched. New Rohan Arun draft #7142 at d446d891ab4c25b3a7df002ae3a9d140b492bfab reports provisional kappa .003643216822476 on the same #7140 source, with full verification pending. It uses an endpoint-funded T2+1,T7+1,T8-1/P1+1 change, distinct from this temporal T4+1,T5+1,T9-1/P3+1,P4+1,P7-1. This package does not claim to beat that draft or compose its change. #7141 covers separate fixed-profile two-blocker searches. Exact source7140 temporal scope was claimed before discovery. Final 00:31 UTC canonical fetch unchanged; newest-eight PR and exact #7142 recheck unchanged at 00:30 UTC.", + "open_questions": [ + { + "question": "Does an independent replay verify the timed e1449 identities and full storage/caller accounting?", + "why_it_matters": "Each changed source and owned inventory needs its own complete application.", + "first_step": "Run the registered certificate/native/application commands and inspect WITNESS.json, PATHS.json and the (58,44,55) lifecycle adapters.", + "blocked_by": "Independent human/formal review and maintainer admission remain." + }, + { + "question": "Does an uncovered temporal domain improve this successor?", + "why_it_matters": "The one-path search stopped at its first positive and established no ceiling.", + "first_step": "Refresh canonical main and overlap, freeze this source, then name one bounded domain and charge every path and buffer.", + "blocked_by": "No later improvement or global optimality is established." + } + ], + "stop_rule": "One new fully checked invoice; refresh before any further research round." +} diff --git a/research/p104-temporal-chart120-split/VALIDATION.md b/research/p104-temporal-chart120-split/VALIDATION.md new file mode 100644 index 0000000000..d75cad1faa --- /dev/null +++ b/research/p104-temporal-chart120-split/VALIDATION.md @@ -0,0 +1,35 @@ +# Validation status and limits + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. Apache-2.0. + +All three direct CPython 3.14.7 commands passed: timed certificate, full native and complete 17-stage application. Final registered isolated Python 3.12.16 replay passed all three commands and 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 24 frozen scientific code, input, manifest and receipt hashes remained unchanged. + +Reproduction uses three registered commands: verify_certificate.py, verify_native.py and verify.py. They compare every certificate/native/application receipt field. The complete 30-file predecessor archive is authenticated by inventory, byte size, Git blob and SHA256; reconstructed native words are compared by canonical decompressed bytes. REUSE.json additionally authenticates six unchanged implementation files against the frozen parent. + +The native and timed certificate passed on their first attempts. Both precision paths retain the lifecycle assertion, updated to the exact (58,44,55) tuple: lifetimes, peak and labels. An extra uncharged lifetime is rejected. No frozen source bytes are edited. + +The certificate checks every timed row/column coefficient and ten temporal/cost controls. The native checks both operator directions, inventory/deltas, independent rational and integer 1125/F25 grids, F24 and insufficient odd-scale rejection, explicit owned lifecycle and peak, 18 controls, six 512-column chart/phase tests, the full 18-stage ingredient invoice/ordinary/precision and finite physical routes. The complete 17-stage application separately covers all 3,038 paid/helper maps and 104 main boundaries, caller grids/envelopes, ordinary/owned-stock/physical/fixed-tape costs, both directed prices and 54+4 outer conditions. The ten certificate controls are included in the 18 native controls; they are not counted as 28 distinct controls. + +Finite evidence does not discharge native_all_columns, owned_erasure, compiler, precision_tape or analytic_recovery as universal obligations. Human/formal acceptance, maintainer admission and compiled top-level execution remain. Hosted CI is reported separately at the public head. + +Direct commands: + +```sh +python3 -B research/p104-temporal-chart120-split/verify_certificate.py --out /tmp/kappa-chart120-certificate-result.json +python3 -B research/p104-temporal-chart120-split/verify_native.py --out /tmp/kappa-chart120-native-result.json +python3 -B research/p104-temporal-chart120-split/verify.py --out /tmp/kappa-chart120-application-result.json +``` + +These generate CERTIFICATE.json, NATIVE-RESULT.json and RESULT.json. The registered hook reruns without --out and compares every field. + + +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-temporal-chart120-split/VERIFY.json b/research/p104-temporal-chart120-split/VERIFY.json new file mode 100644 index 0000000000..de0730401e --- /dev/null +++ b/research/p104-temporal-chart120-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 complete 30-file #7140 export and nested closure; reconstruct two timed prefix rows, six suffix columns and c=d=e1449; exact paths, unit pairing, full candidate and ten controls; compare every certificate field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_native.py" + ], + "timeout_seconds": 510, + "checks": "Reconstruct complete source/candidate; whole forward/adjoint, inventory/deltas and exact 58/44/55 lifecycle; independent 1125/F25 grids; ingredient cost/precision, six 512-column chart/phase checks, 18 native controls and finite physical routes; every frozen field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 570, + "checks": "Full unchanged 17-stage caller; all 3038 paid/helper maps and 104 main boundaries; fresh ordinary/owned-stock/physical/grid/envelope/compiler costs, both prices and 54+4 outer conditions; every application field." + } + ] +} diff --git a/research/p104-temporal-chart120-split/WITNESS.json b/research/p104-temporal-chart120-split/WITNESS.json new file mode 100644 index 0000000000..e1140f48b3 --- /dev/null +++ b/research/p104-temporal-chart120-split/WITNESS.json @@ -0,0 +1,104 @@ +{ + "frame": 120, + "cut": 39225, + "pivot": 648, + "ranks": [ + 5, + 4 + ], + "c": { + "1449": "1" + }, + "d": { + "1449": "1" + }, + "gathers": [ + { + "cut": 39225, + "role": 649, + "frame": 120, + "path": 0, + "coefficient": "1" + }, + { + "cut": 39224, + "role": 1449, + "frame": 120, + "path": 4, + "coefficient": "1" + } + ], + "injections": [ + { + "cut": 41668, + "role": 198, + "frame": 120, + "paid_path": 0, + "coefficient": "1" + }, + { + "cut": 40403, + "role": 1488, + "frame": 120, + "path": 6, + "coefficient": "-1/2" + }, + { + "cut": 39298, + "role": 1305, + "frame": 120, + "path": 3, + "coefficient": "-1/2" + }, + { + "cut": 39280, + "role": 650, + "frame": 120, + "path": 1, + "coefficient": "-1/2" + }, + { + "cut": 41470, + "role": 651, + "frame": 120, + "path": 2, + "coefficient": "-1/2" + }, + { + "cut": 41465, + "role": 1449, + "frame": 120, + "path": 5, + "coefficient": "1" + } + ], + "boundary_basis_length": 4, + "paid_delta": { + "4": 1, + "3": 1, + "7": -1 + }, + "paid_path": 0, + "path": { + "role": 198, + "lo": 41607, + "hi": 41668, + "frame": 120, + "moves": [ + 41667 + ], + "old": 597, + "new": 207, + "old_paid": [ + 7 + ], + "new_paid": [ + 4, + 3 + ], + "cost": 0.017314094156310134, + "gain": 0.022372302922640586, + "private": false + }, + "owned_lifetimes_added": 2 +} diff --git a/research/p104-temporal-chart120-split/WORD.json.gz b/research/p104-temporal-chart120-split/WORD.json.gz new file mode 100644 index 0000000000..34b12281e0 Binary files /dev/null and b/research/p104-temporal-chart120-split/WORD.json.gz differ diff --git a/research/p104-temporal-chart120-split/adapt.py b/research/p104-temporal-chart120-split/adapt.py new file mode 100644 index 0000000000..8b6907ff37 --- /dev/null +++ b/research/p104-temporal-chart120-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(".003643180671645")') + # 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) == (58, 44, 55)\')\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-temporal-chart120-split/certificate.py b/research/p104-temporal-chart120-split/certificate.py new file mode 100644 index 0000000000..99f017221f --- /dev/null +++ b/research/p104-temporal-chart120-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-temporal-chart120-split/construct.py b/research/p104-temporal-chart120-split/construct.py new file mode 100644 index 0000000000..0e1fc67ac5 --- /dev/null +++ b/research/p104-temporal-chart120-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-temporal-chart120-split/derive_grid.py b/research/p104-temporal-chart120-split/derive_grid.py new file mode 100644 index 0000000000..f8cb37f00b --- /dev/null +++ b/research/p104-temporal-chart120-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-temporal-chart120-split/inputs/previous-causal-buffer.tar b/research/p104-temporal-chart120-split/inputs/previous-causal-buffer.tar new file mode 100644 index 0000000000..1bd568fa06 Binary files /dev/null and b/research/p104-temporal-chart120-split/inputs/previous-causal-buffer.tar differ diff --git a/research/p104-temporal-chart120-split/price.py b/research/p104-temporal-chart120-split/price.py new file mode 100644 index 0000000000..8590ccd599 --- /dev/null +++ b/research/p104-temporal-chart120-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 current7140 causal-buffer 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-temporal-chart120-split/source.py b/research/p104-temporal-chart120-split/source.py new file mode 100644 index 0000000000..091d254cf2 --- /dev/null +++ b/research/p104-temporal-chart120-split/source.py @@ -0,0 +1,62 @@ +"""Authenticate #7140 causal-buffer'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 #7140 causal-buffer export') + old_path=list(sys.path) + with tempfile.TemporaryDirectory(prefix='p104-temporal_chart120-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'] + reuse=read(HERE/'REUSE.json');need(reuse['head']==pin['head'],'Exact implementation reuse source') + for item in reuse['files']: + name=item['path'];need(Path(name).name==name,'Root implementation file') + a=(HERE/name).read_bytes();b=(parent/name).read_bytes() + need(a==b and sha256(a).hexdigest()==item['sha256'],'Byte-identical credited implementation '+name) + imports=load('temporal_chart120_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_chart120_native_source',parent/'source.py') + with original.sources() as (vendor,archive,rank9,bundle,oldparent,word): + saved={name:sys.modules.get(name)for name in ('support','split')} + try: + load('support',parent/'support.py');load('split',parent/'split.py') + emitter=load('temporal_chart120_parent_construct',parent/'construct.py') + word=emitter.construct(word,read(parent/'WITNESS.json'),read(parent/'PATHS.json')) + finally: + for name,obj in saved.items(): + if obj is None:sys.modules.pop(name,None) + else:sys.modules[name]=obj + need(canonical(word)==gzip.decompress((parent/'WORD.json.gz').read_bytes()),'Every reconstructed previous causal-buffer native byte') + need(sha256(canonical(word)).hexdigest()=='81f9b2e0a170aa3ab0cd4bb1056c834ebe0b98eaf37abe5986c6e53abd1257ea','Exact frozen current native') + yield vendor,archive,rank9,bundle,parent,word diff --git a/research/p104-temporal-chart120-split/split.py b/research/p104-temporal-chart120-split/split.py new file mode 100644 index 0000000000..f1c7609653 --- /dev/null +++ b/research/p104-temporal-chart120-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-temporal-chart120-split/support.py b/research/p104-temporal-chart120-split/support.py new file mode 100644 index 0000000000..192cd38d27 --- /dev/null +++ b/research/p104-temporal-chart120-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) == (58, 44, 55)'),)) + need(owned_check.validate_word(new)['lifetimes']==58,'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_TEMPORAL_CHART120_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)