diff --git a/research/p104-funded-residual-split/APPLICATION.md b/research/p104-funded-residual-split/APPLICATION.md new file mode 100644 index 0000000000..c074611070 --- /dev/null +++ b/research/p104-funded-residual-split/APPLICATION.md @@ -0,0 +1,29 @@ +# Conditional application to the residual native and signed caller + +This applies Rohan Arun's #7113 component proof and #7116/#7117's changed-native adaptation to the exact residual native. The input closure and explicit construction are in PROOF.md. Both artifact hashes and public heads are in README.md. The five inherited assumptions and selected completed BIT predecessor are retained. The source-specific proof template is the [#7000 application review](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), including its BIT ambient 134 repair. Its generic root/storage and scalar/physical arguments require the substitutions below; a predecessor's numeric receipt alone is insufficient. + +## Native and caller operator substitution + +The new exact constructor preserves every independent arbitrary-input native endpoint while replacing one rank-nine helper with rank-eight and rank-one helpers. One paid rank-five move is subdivided into rank four and rank one, with every new occurrence charged. Two rank-one exits are retimed without changing their ranks. It checks all three public retiming intervals, the entire rational prefix/suffix, both basis identities and the retained scalar alphabet. Its complete forward and adjoint replays include every owned row. All 3,048 current paid/helper chart pairs and 104 main boundary pairs are then rebuilt with the pinned compiler and distinct signed-Pauli/absolute-phase interpreter. For these Clifford maps, the signed Pauli action fixes the operator up to global phase, which the exact Gaussian check fixes. Thus every column of each chart map is determined. The fresh replay includes a deliberately wrong absolute phase. + +The unchanged 17-stage caller has five noncommuting quarter turns and twelve padding turns in inverse pairs. Its grouped idle bases lie over Z[1/30]. Its exact rational and integer Laurent engines agree on all 72 output fields for every formal central/body variable. In the physical substitution, seventeen disjoint eight-axis stage blocks and nine central axes use ambient 145. For each invocation, exchange the eight native complement axes with the fresh stage block while fixing the routed central axis and spectator axes. The phase-polynomial checks verify both directions. Literal A and B routes then apply commuting body operators on disjoint stage blocks. + +A signed rank-nine idle uses one positive rank-nine recursive request plus the charged ordinary conjugation/phase implementing the inverse on the protected central axis. Current finite signed-child checks cover widths 1,2,3; the symbolic phase geometry supplies the disjoint-axis substitution. The ordered occurrence digest is recomputed from the literal caller and current native geometry. It binds 13,600 native contact boundaries, 110,689 paid positions and 22,223 productive fields. Main-owner aliasing is rejected. Allocate 18,479 distinct (stage,helper) public inputs and 867 reserved native owned banks, plus the retained serial query/LAMBDA bank. The surplus is 1,424. The ownership discipline and owned-erasure hypothesis remain explicit. + +## Common-grid and fixed-root induction + +Scale each of the 3,744 raw caller main input fields by 675 and divide each completed caller main output by 675. The independent integer Laurent replay checks the necessary valuations 3³ and 5², rejects a lower exponent of either prime, and uses safe binary valuation 381. Every normalized main coefficient and pre-ADD product is integral on that odd grid. Substituting actual binary Clifford address operators introduces only powers of two, so the odd-divisibility invariant transfers to whole arrays and all spectators. + +Within each native invocation, scale all 1,487 public fields by 1125 and unscale the completed returns. The separate exact prefix/pre-product derivation and integer replay establish the native grid at fractional height 24. Fresh helpers receive their own independent inputs. The exact native endpoint ensures these helper inputs do not perturb the normalized main caller invariant. Both odd scales are included simultaneously in the unfinished-context mass allowance. + +The fresh forward/adjoint envelope has height 405 and context mass exponent 1169, giving c=2338. This value is recomputed from the current word and caller; #7117's previous allowance was 2336. It remains below 4096. The same conservative ambient 153 compiler threshold funds it: Kstar has 14,093 bits and c·Kstar has 14,104 bits, below H=16487800000000000000000. The independent inequalities check every rounded caller bound as well. Apply the retained full-root common-format induction with fixed padding, signed width p+h+2D+3, fractional width p+D, and 26 temporary bits. Completed child returns preserve this format. Exact finite-state odd division retains the reviewed carry/remainder invariant. + +## Physical upper-cost substitution + +The source-unit ordinary bound 777,622,672 includes the caller and native conversion services. It is distinct from the physical-machine bound. The fresh raw-occurrence counts give 1,144,763 native scalar macro inputs, 117,856 caller macro inputs and 58,046 conversions. The retained conservative factor 32 gives 42,261,280 scalar services; with the reviewed 2²⁰ service constant this is 44,314,163,937,280 times the root scalar-width envelope. Numerators of all actual native/caller instructions and both conversion scales fit 24 bits. + +The current occurrence count gives 298,672 monomial map slots. At actual ambient 145, the retained elementary bound 4(145+1)² is 85,264 records per map, hence at most 25,465,969,408 elementary records per raw occurrence. Use actual owner widths and these finite coefficients in the same fixed-tape stock and movement envelopes from the selected review. The positive compiler/outer slack permits enlarging the eventual cutoffs. This is a conditional asymptotic substitution, not an enumerated machine trace. + +The recomputed complete recurrence has the bracket and claim in README.md; both exact price engines, the compiler and 54 strict plus 4 functional outer inequalities pass. These checks establish the stated conditional component application under the five assumptions. Independent mathematical review, formal-kernel validation and maintainer admission are separate obligations. + +Credit Rohan Arun for the #7113 proof and implementation, Douglas Colkitt and the #7000 application reviewers, the retained compiler/precision/source authors, and the complete lineage in README.md. Adapted for this exact residual construction by dillona with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-funded-residual-split/DISCOVERY.json b/research/p104-funded-residual-split/DISCOVERY.json new file mode 100644 index 0000000000..da21446c51 --- /dev/null +++ b/research/p104-funded-residual-split/DISCOVERY.json @@ -0,0 +1,132 @@ +{ + "scope": "Local-only exploratory nomination; certificate replay uses only the exact published witness.", + "source_head": "092255ac8e9ed07ea59fee87c9711a5d72b10750", + "word_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "method": "Complete boundary kernels and Matarener pairing decision, plus basis-pair nominations under the sum of paid path costs. This is not exhaustive rational cost optimization.", + "stats": { + "systems": 38329, + "saved": 10011, + "pairs": 43629, + "hits": 17, + "classes": { + "F1zero": 8010, + "witness": 1735, + "F2zero": 266 + }, + "rescued": 0, + "budget_reject": { + "8": 3182, + "10": 2475, + "6": 3882, + "13": 1249, + "12": 1986, + "4": 2337, + "9": 3081, + "7": 3800, + "14": 1355, + "15": 1771, + "5": 2874, + "3": 3326, + "2": 1258, + "18": 975, + "16": 1311, + "21": 782, + "24": 492, + "11": 2052, + "17": 1199, + "20": 767, + "19": 983, + "22": 568, + "25": 235, + "23": 656, + "28": 196, + "29": 115, + "27": 163, + "26": 225, + "30": 104, + "31": 34, + "33": 5, + "32": 10 + }, + "best_budget": { + "cut": 45219, + "frame": 246, + "cost": 0.009069905710861192, + "gain": 0.011365962450296863, + "paths": [ + { + "role": 789, + "lo": 36308, + "hi": 56318, + "frame": 246, + "old": 232, + "new": 127, + "moves": [ + 44678 + ], + "old_paid": [ + 5 + ], + "new_paid": [ + 4, + 1 + ], + "cost": 0.009069905710861192, + "private": false, + "neutral": false + }, + { + "role": 472, + "lo": 44118, + "hi": 46149, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 44123 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 1359, + "lo": 44152, + "hi": 47585, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 45185 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + } + ], + "paid_roles": 1 + } + }, + "legal_nominations": 17, + "full_native_checked_indices": [ + 5, + 13 + ], + "selected_index": 5, + "selected_reason": "Same exact invoice; fewer scalar instructions (28 versus32) in the two replayed candidates.", + "remaining": "Other15nominations were not constructed; no optimality claim. Search code/results remain local; the exact selected witness and full replay are public." +} diff --git a/research/p104-funded-residual-split/ENVIRONMENT.json b/research/p104-funded-residual-split/ENVIRONMENT.json new file mode 100644 index 0000000000..3d683f2815 --- /dev/null +++ b/research/p104-funded-residual-split/ENVIRONMENT.json @@ -0,0 +1,14 @@ +{ + "initial_python": "3.14.7", + "initial_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 both complete commands; every native and composition receipt field matched" + }, + "dependencies": "Python standard library", + "interpreter_origin": "Official Astral python-build-standalone release20261026; isolated /tmp installation", + "interpreter_archive_sha256": "fbf4afef53c2a6b72bb741bc06d5671a9dfaf87bd84e5aa73ac9b3d0d589f14e", + "hosted_ci": "Not yet published; no hosted pass claimed.", + "completed_utc": "2026-11-10T18:52:07.858281+00:00" +} diff --git a/research/p104-funded-residual-split/INPUTS.json b/research/p104-funded-residual-split/INPUTS.json new file mode 100644 index 0000000000..f62d22126e --- /dev/null +++ b/research/p104-funded-residual-split/INPUTS.json @@ -0,0 +1,159 @@ +{ + "head": "092255ac8e9ed07ea59fee87c9711a5d72b10750", + "pr": 7117, + "prefix": "research/p104-funded-cohort-split", + "archive": "inputs/pr7117.tar", + "archive_sha256": "5dad877e3ecfaada8542c69d1516ecc951086d49cc00fc0647efcaa22defd080", + "files": [ + { + "path": "research/p104-funded-cohort-split/APPLICATION.md", + "size": 6616, + "sha256": "8862910bd716a84c82c904cea38b288029a7c7eece12faf94571bd2339112a2b", + "git_blob": "f549ac13630d2a925dd549ee0efceb762225a311" + }, + { + "path": "research/p104-funded-cohort-split/DISCOVERY.json", + "size": 3278, + "sha256": "368fe43e32c965247b97745b81db2ec40c6e15283a88787f1abfab18f2292735", + "git_blob": "df29aa9426416dae1398f57ef1114057bc08212c" + }, + { + "path": "research/p104-funded-cohort-split/ENVIRONMENT.json", + "size": 708, + "sha256": "88c8c914cc40e22abc3664962ad40b8861b61add036cf71582a9576ec20c0dac", + "git_blob": "7503136c9028c893708da2535df5a6fbd25a02a4" + }, + { + "path": "research/p104-funded-cohort-split/INPUTS.json", + "size": 4374, + "sha256": "814c07335ce9db16275099fad99028223e12892ad482d5bb14ff225c292943f0", + "git_blob": "69b1a847b6f78ed33b8c233f4d78542fd61f456a" + }, + { + "path": "research/p104-funded-cohort-split/NATIVE-RESULT.json", + "size": 74095, + "sha256": "749df0962d8346090ff6785694b4cacc0f79fa84e14620da96fa4bee3bcabcd5", + "git_blob": "708e7b7cfa66f28a0610d6e8fcaf2e329e938582" + }, + { + "path": "research/p104-funded-cohort-split/PROOF.md", + "size": 4700, + "sha256": "b7e85908362d6d7f32db3d1cbf1b70c3878fb630b84bbfaf77829c4df6d17267", + "git_blob": "0818a539373889d588d3a5a02765909fb7162ae2" + }, + { + "path": "research/p104-funded-cohort-split/README.md", + "size": 6353, + "sha256": "2587769728ecd5bd2d65dc1028a13f398efff33f56a602d8c12c9fd506425864", + "git_blob": "91c1db6541ca9d9dd0d1a6818f97ff99b094330d" + }, + { + "path": "research/p104-funded-cohort-split/REPLAY.txt", + "size": 4068, + "sha256": "540bb6f458ef6f0821b93ffb29e7bc261d9f71b56d44b7093987e6682a4647f0", + "git_blob": "068a55d94c5e8c3ff9050d68936bd7076915bfbe" + }, + { + "path": "research/p104-funded-cohort-split/RESULT.json", + "size": 75443, + "sha256": "7dcd60ddaa11e1e6743c6eb8ca880d6b01d9bba9526b64b024a63ca6bf74efff", + "git_blob": "7d2efa1e285f37ec47c45ce02e6ca2c9f39bb302" + }, + { + "path": "research/p104-funded-cohort-split/SOURCES.json", + "size": 856, + "sha256": "8b58a30ae55396b8d108de4ee2c7c6ac75dc1096948c9ac3796c20b21b1c9372", + "git_blob": "c4150ae39789502a4adf89e8f5235995d458a72e" + }, + { + "path": "research/p104-funded-cohort-split/TASK.json", + "size": 11270, + "sha256": "a0886cdd4147807a0566ec8b28a2660068499be7931824222541d164c741b578", + "git_blob": "a780658f5b109c08c17b4400fc4875eceb758c29" + }, + { + "path": "research/p104-funded-cohort-split/VALIDATION.md", + "size": 2009, + "sha256": "54e4c9554238fe96ce2bbfb000e125234aa365c9b923e0b380d6bb28b1dabb02", + "git_blob": "967bf87c0141a551bc577a0127ec891028bb0889" + }, + { + "path": "research/p104-funded-cohort-split/VERIFY.json", + "size": 1010, + "sha256": "be68dfbcdf170bf7912b04eb6a5988d58b1fc445aff05fffe653b2673983aa1e", + "git_blob": "51e4ea1272fd21a660cbfce8a29ca510ab032412" + }, + { + "path": "research/p104-funded-cohort-split/WITNESS.json", + "size": 9878, + "sha256": "da1c5b5a8937ef4042fea4c8f4291d9a1f67ee7218cea77e66d64e45bb937ae8", + "git_blob": "f1bb5022e838f67f5c8e08a4d7bccc013b86e415" + }, + { + "path": "research/p104-funded-cohort-split/WORD.json.gz", + "size": 364229, + "sha256": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56", + "git_blob": "bbf1b6aed7ee72471af83878052a21c492944046" + }, + { + "path": "research/p104-funded-cohort-split/adapt.py", + "size": 2163, + "sha256": "a7fc61b72a0cfdf46279a773240ec76342c457d0ea286e26170b07c1319f9e5e", + "git_blob": "0c7a35719ded0c5482f8857d3e04a6c059f9d937" + }, + { + "path": "research/p104-funded-cohort-split/construct.py", + "size": 3061, + "sha256": "42ffab76b8664088f444ba7d815537a541af72c5fa5eef897989b90399b9e564", + "git_blob": "748bfe2be2e5fffc1dfa9bdfa261bfcc8da16088" + }, + { + "path": "research/p104-funded-cohort-split/derive_grid.py", + "size": 1510, + "sha256": "ceb7a44ef19d72a16db7b43c65c85910d965499d1715436011de32af5d39dbb0", + "git_blob": "f8cb37f00bcd197d77bbb205dae3c1a40c0aa680" + }, + { + "path": "research/p104-funded-cohort-split/inputs/pr7116.tar", + "size": 5611520, + "sha256": "eff4dc88c670c15f231a60e3cddb8fc61d633d4f9ae2dc47be9597f4c5678d90", + "git_blob": "6aa112532c4503d3e5f9ea7c78e6b1d21d17bacd" + }, + { + "path": "research/p104-funded-cohort-split/price.py", + "size": 3635, + "sha256": "3dd1ae8fa6a6147d75e153975d3eabf3059e761a7671e5e4e14e62d58ef69bad", + "git_blob": "7c47ea963c10e7da00b280277f22d03561da51aa" + }, + { + "path": "research/p104-funded-cohort-split/source.py", + "size": 3286, + "sha256": "0dc9aea586ef0ce4858464993b656d723d6f97b117312e2c0961f0af70fcfae1", + "git_blob": "054b3d947781f42f8da04d34cbb75b9ce1459bd7" + }, + { + "path": "research/p104-funded-cohort-split/split.py", + "size": 6432, + "sha256": "3d529d78994504ad591a3afade4dab094751c1c221edbab10165290314cf0894", + "git_blob": "5407e8959b8723464aee68eea6ffcf2ee75cc3b7" + }, + { + "path": "research/p104-funded-cohort-split/support.py", + "size": 606, + "sha256": "f3e6eeb879480715c5c32c1a390a63c57d26ea1c9a9cbdb89b83ca34260e47f6", + "git_blob": "192cd38d27e4b732981b98730459a041dcfb52e7" + }, + { + "path": "research/p104-funded-cohort-split/verify.py", + "size": 3446, + "sha256": "003e89bea6719c1bedfc06ce41f92d47a3578cedf8d6bab0c64bd31f483e2712", + "git_blob": "9356a6eea542a4ccbc79966eb58b95daf682ad00" + }, + { + "path": "research/p104-funded-cohort-split/verify_native.py", + "size": 13021, + "sha256": "82b736ab1be73fcf760dc22ebed9331eb8bb52bd1a86646355e495afebc57a9a", + "git_blob": "a3345abf9f363d911fead5947a68bfbbc7e61273" + } + ] +} diff --git a/research/p104-funded-residual-split/NATIVE-RESULT.json b/research/p104-funded-residual-split/NATIVE-RESULT.json new file mode 100644 index 0000000000..81793c79a8 --- /dev/null +++ b/research/p104-funded-residual-split/NATIVE-RESULT.json @@ -0,0 +1,3084 @@ +{ + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "new_pairs": [ + [ + 232, + 246 + ] + ], + "rechecked_pairs": [ + { + "columns": 512, + "pair": [ + 3, + 127 + ], + "rank": 9 + }, + { + "columns": 512, + "pair": [ + 3, + 246 + ], + "rank": 8 + }, + { + "columns": 512, + "pair": [ + 232, + 246 + ], + "rank": 4 + }, + { + "columns": 512, + "pair": [ + 246, + 127 + ], + "rank": 1 + } + ], + "wrong_phase_rejected": true + }, + "controls": { + "duplicate_retimed_role": true, + "insufficient_fractional_grid": true, + "insufficient_odd_grid": true, + "intervening_scalar_contact": true, + "missing_cut_correction": true, + "missing_retiming_1359": true, + "missing_retiming_472": true, + "missing_retiming_789": true, + "missing_successor_correction": true, + "omitted_old_move": true, + "unpaid_subdivisions": true, + "wrong_cut_frame": true, + "wrong_declared_path_ranks": true, + "wrong_prefix": true, + "wrong_successor_frame": true, + "wrong_suffix": true + }, + "derived_grid": { + "coefficient_visits": 14988301, + "fractional_bits": 24, + "mass_witness": [ + 64684, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "1630603680282225/16384", + "unscaled_maximum_mass": "7247127467921/81920" + }, + "forward": { + "coefficient_positions": 2365444, + "fractional_bits": 24, + "grid": 1125, + "rows": 1538 + }, + "gate": { + "BIT_margin": "12821853961693/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16480300000000000000000", + "alpha": [ + 0.9999999999999994, + 0.9999999999999994 + ], + "claim": "3638471460383/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8799647317323606, + 0.8799647317323606 + ], + "derivative_upper": -407649.87027163, + "gamma": [ + 0.9499255738464675, + 0.9499255738464675 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3638471460383/1000000000000000": [ + "124146499679431506714662405100566875584313579268752496592451625674549355722491/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124146499679431506714662405100566875584313579268752496592451625674549355724439/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363847146038307/100000000000000000": [ + "124146499679433793434492263978462284071828192845040615340617234327665289952313/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124146499679433793434492263978462284071828192845040615340617234327665289954271/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2232, + "moment_margin_float": { + "18192357301917368142749763373831/5000000000000000000000000000000000": [ + 1.1553199653219178e-29, + 1.1553199653219178e-29 + ], + "363847146038307/100000000000000000": [ + 1.673495341997269e-10, + 1.673495341997269e-10 + ], + "36384714603834736285499526747663/10000000000000000000000000000000000": [ + -2.9908073148060215e-29, + -2.9908073148060215e-29 + ] + }, + "moment_margins": { + "18192357301917368142749763373831/5000000000000000000000000000000000": [ + "115531996532191788491032276865166452195058464637899/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "577659982660958942455161384325832260975292344031757/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363847146038307/100000000000000000": [ + "418373835499317226490872414846906526096685822901528893506002806849717/2500000000000000000000000000000000000000000000000000000000000000000000000000000", + "8367476709986344529817448296938130521933716458030577870120056157975651/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36384714603834736285499526747663/10000000000000000000000000000000000": [ + "-1495403657403010699476911652672289697489733806349021/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-747701828701505349738455826336144848744866892666257/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18192357301917368142749763373831/5000000000000000000000000000000000", + "36384714603834736285499526747663/10000000000000000000000000000000000" + ], + "tested": "363847146038307/100000000000000000", + "written_log_power": 2233 + }, + "grid": { + "dyadic_height": 24, + "maximum_scaled_mass": "1630603680282225/16384", + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "odd_grid_lcm": 1125, + "opcodes": { + "ADD": 63548, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6289, + "SCALE": 3682 + }, + "owned_lifetimes": 54, + "owned_peak": 43, + "owned_rise_mass": 56, + "owned_rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + }, + "paid": { + "1": 4033, + "2": 841, + "3": 817, + "4": 238, + "5": 326, + "6": 16, + "7": 12, + "8": 6 + } + }, + "invoice": { + "P": { + "1": 72978, + "16": 416, + "2": 15138, + "24": 416, + "3": 14706, + "32": 416, + "4": 4284, + "40": 416, + "48": 416, + "5": 5868, + "56": 416, + "6": 288, + "64": 416, + "7": 216, + "8": 780, + "9": 32 + }, + "S": 1520, + "T": { + "1": 288, + "145": 208, + "17": 416, + "2": 324, + "25": 416, + "3": 828, + "33": 416, + "4": 3906, + "41": 416, + "49": 416, + "5": 1278, + "57": 416, + "6": 756, + "65": 416, + "7": 324, + "73": 416, + "8": 1044, + "9": 11234 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036384714603834736285499526747662278650385592182677548961002903861", + "raw_crossing": "0.0036384714603834736285499526747662278650385592182677548961002903861" + }, + "limitations": [ + "Source-aware reuse of attributed engines, not independent human or kernel review.", + "The five framework assumptions remain; the current17-stage application is checked separately by verify.py.", + "Finite physical checks and source-unit bills do not constitute a complete multiplication theorem." + ], + "native": { + "bad_inputs": [], + "events": 73628, + "helpers": { + "1": 16, + "2": 18, + "3": 46, + "4": 217, + "5": 71, + "6": 42, + "7": 18, + "8": 58, + "9": 601 + }, + "lifetimes": 54, + "owned_peak": 43, + "paid": { + "1": 4033, + "2": 841, + "3": 817, + "4": 238, + "5": 326, + "6": 16, + "7": 12, + "8": 6 + }, + "public": 1487, + "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": 851352640, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 148647360, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2783664, + "raw_upper": 833400720, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2174, + "moves": 6289, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9879000, + "scalar_upper": 1988480 + }, + "physical_checks": [ + "verify_host3_odd.py", + "physical.py", + "physical_child.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": 450, + "context_mass_bits": 671, + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "5390636241032014745913296970681253733576209004610219109587333869642552108115176942886533908202542241463651374973651841599566181858472215510582840233067509898522654951650192214125353730213293831755160361591097315067711889099514105210174732968033898712419620761395366844237899723238779416320986933371231040483013/1848234575132758467382193273438208000000000000000000000", + "strict_power_of_two": 849, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "3474017338001263581779056575804976312907821496473076347564750705466474572689314026411553009464806547385073763429273480518974904019388030519722591268417586333771221726618928683838877722074672067929683707874268739915191086889309785537993423131670294053916738112682929710712465930195383811426884795632789251814791633/8871525960637240643434527712503398400000000000000000000", + "strict_power_of_two": 856, + "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": "89243232542171007671106054461651750689273748493744599352575099351483350703049898653624853055258310437413919688423155569796736742210209549476100054534322164660356592949952272238393989612749124339322304159657757325045601625564804446205670067692109525069098854283284836189786711733675083601072778493436385006935442943589/47314805123398616764984147800018124800000000000000000000", + "strict_power_of_two": 868, + "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": "3474017338001263581779056575804976312907821496473076347564750705466474572689314026411553009464806547385073763429273480518974904019388030519722591268417586333771221726618928683838877722074672067929683707874268739915191086889309785537993423131670294053916738112682929710712465930195383811426884795632789251814791633/8871525960637240643434527712503398400000000000000000000", + "strict_power_of_two": 856, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "108953008180223101387180407553272122876324988162936311561981445459625663547090506395592285820269221349623946762082486524417167986430576513240979210044407655417067209139338708661585232348845788905264767223220334850380892582670371049559353914686266248222337118377831093051429806267502738582530079439106291867306869249237852491756494237919482162931184521158414256686409028877419324317196563217148155678670220753282554633220508697185151854950631/320247285442140769134110953618454922992625780457095452694524461056000000000000000000000000000000000000000000", + "strict_power_of_two": 1105, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19566, + "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": "5390636241032014745913296970681253733576209004610219109587333869642552108115176942886533908202542241463651374973651841599566181858472215510582840233067509898522654951650192214125353730213293831755160361591097315067711889099514105210174732968033898712419620761395366844237899723238779416320986933371231040483013/1848234575132758467382193273438208000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "3474017338001263581779056575804976312907821496473076347564750705466474572689314026411553009464806547385073763429273480518974904019388030519722591268417586333771221726618928683838877722074672067929683707874268739915191086889309785537993423131670294053916738112682929710712465930195383811426884795632789251814791633/8871525960637240643434527712503398400000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "3474017338001263581779056575804976312907821496473076347564750705466474572689314026411553009464806547385073763429273480518974904019388030519722591268417586333771221726618928683838877722074672067929683707874268739915191086889309785537993423131670294053916738103811403750075225286760856098923486395632789251814791633/8871525960637240643434527712503398400000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "5390636241032014745913296970681253733576209004610219109587333869642552108115176942886533908202542241463651374973651841599566181858472215510582840233067509898522654951650192214125353730213293831755160361591097315067711889099514105210174732968033898712419620761395366844237899723238779416320986933371231040483013/1848234575132758467382193273438208000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "3474017338001263581779056575804976312907821496473076347564750705466474572689314026411553009464806547385073763429273480518974904019388030519722591268417586333771221726618928683838877722074672067929683707874268739915191086889309785537993423131670294053916738112682929710712465930195383811426884795632789251814791633/8871525960637240643434527712503398400000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "683082422367452135377935922792913852918382110158202006090730561360250386528298426975666307201992013234676243488979595701585075495943/338421858239640832650548084736000000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "1958091468522990138451148655884099778944334041038404281644350101169976987527070420476182823875505985047726579076957455170174154936706557153397/21658998927337013289635077423104000000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "25268923792128217377877726854023141772158136852171159445411821784193867888946214438107859712237017311221269945059563968415358547735911414210477911369/1082949946366850664481753871155200000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "89754324359810123877036574097089923218418842981800772715112989792890346376140272877849517753961139287502646887162813147142450712487143228398788474132367081393/7219666309112337763211692474368000000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "161078909600897404506799525689298089870309141070277139931923477842896541108015200010733584732314492960323639388924792238275100956518780154841164703188982004839433934279/5414749731834253322408769355776000000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "2442573466566050589922712105474371616287682608335586059106121075959660145802823583452222696997735724818856740037235712346355443253028111440489672336654986164123480278288465372121/34654398283739221263416123876966400000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "10081052641393563704169778439248261395601418352623733412486476883882242271279582624355408113844825435174718978912925055577943506947051398294105021984368273714526935012225207530835853440167/14439332618224675526423384948736000000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "109118393193799853655702483406773452337208577197982070539121926678534436191545483049693150432512534927060189109610838555087443540320563878671504702823887916608364807266496893043489946803131303658103/86635995709348053158540309692416000000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "3131690692509595446321666165526832560314844888685099678237754506253139014902827287881951515458206603108138560465706449496736487462134800648630324372885793138600754892171595123243921544374794881828704428638516584791034564663311526343170975079/21658998927337013289635077423104000000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "39065084507484319134887317116640680431395427393132950022875218990479944754222924580670579358924274647216072820429596570073156519172201380075600469161679483354093647125671595891099599581947997339786601904299189141087106748483724438926425131344831569081/346543982837392212634161238769664000000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "174211683731412467137947224897486891882093204330991177975774025364974995165100690729601541153283125867411824391998312289451039276634818297203142806971880377187417998152464817896709466452305990471985110140053033998131943892388153069431329162189209756391236585761/1386175931349568850536644955078656000000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "18736803915885285462208163483921233722951804629171290676181247207283082288029778947758140110173090854116020880779065805362512724080536610948215078283781920343184396124499323744845781138617746464747794833466174714184447272789818690957331033761008928413855762907673089419/154019547927729872281849439453184000000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "114971542286500038000333933970131689854276162928336701913863847371663628991061312774096119011014618667690902039359075898259388905302911323735982474814708237863886114391058184074014643819374751050801901897084508449208149565806361026921745989666407254870106934357604781731519569097/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "11345564763941597524916926008890282458944954221208091987942087474510724307667028833805447578394283360958752294576386319102340506820860542890478850896657731394782687025222203940827892118074131420495014205793427285678622899624661750946616293865337197692820743288056152651507101176462595671/1386175931349568850536644955078656000000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "5542365172279243846861113416249792248394266830344608533823229070127523396304921451734275833904604405084301821713999863614533891380096854008607021371057766180386575266297577681617536203295187608366641236871467161507620617573115005768473489706212724829323880754901793998971305750891653977599796609/11089407450796550804293159640629248000000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "11445243140791600098060365216771675498370607675227716791200802333719601067910007062534619909316711652087254579812964253409712779800875360060267611755843393784865760891605361103041028100087088112170418739345516611600491251846031294924495642741147862657112121903868554405562414944520442518740515024959391/2217881490159310160858631928125849600000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "5390636241032014745913296970681253733576209004610219109587333869642552108115176942886533908202542241463651374973651841599566181858472215510582840233067509898522654951650192214125353730213293831755160361591097315067711889099514105210174732968033898712419620761395366844237899723238779416320986933371231040483013/1848234575132758467382193273438208000000000000000000000", + "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": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 73628, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 257, + "witness": { + "cut": 72908, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 72908, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73628, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63548, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6289, + "SCALE": 3682 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1487, + "scalars": { + "dyadic": 61945, + "integer": 39244, + "noninteger": 27987, + "odd": 5286 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + }, + "M": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 14988301, + "dyadic_height": 24, + "mass_witness": [ + 64684, + "stored add" + ], + "maximum_scaled_mass": "1630603680282225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + } + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "41322606865323343680498988560398322272905598970035919580115728788379461661297/1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2066130343266167184024949428019916113645279948501795979005786439418973101730563/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003638471460383", + "gain": "9.9665533E-8", + "gain_exact": "99665533/1000000000000000", + "independent_raw_bracket": [ + "0.00363847146038347362854995267476622", + "0.00363847146038347362854995267476623" + ], + "previous_claim": "72767435897/20000000000000", + "raw_bracket": [ + "0.0036384714603834736285499526747662", + "0.0036384714603834736285499526747663" + ] + }, + "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": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3" + }, + "source_head": "092255ac8e9ed07ea59fee87c9711a5d72b10750", + "status": "PASS_P104_FUNDED_RESIDUAL_NATIVE", + "word_canonical_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3" +} diff --git a/research/p104-funded-residual-split/PROOF.md b/research/p104-funded-residual-split/PROOF.md new file mode 100644 index 0000000000..6612493e44 --- /dev/null +++ b/research/p104-funded-residual-split/PROOF.md @@ -0,0 +1,39 @@ +# A residual helper split on the funded word + +The exact source is #7117 at `092255ac8e9ed07ea59fee87c9711a5d72b10750`. Its 25-file export and nested source closure are authenticated before import, and every native byte is reconstructed. The source canonical word hash is `954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8`. All indices below refer to that frozen source before insertion. The signed 17-stage caller is unchanged. + +## Legal meeting + +At cut 45209, bring public roles 789, 472, 1359 to chart 246. Role 789's MOVE 44678 goes 232→127, rank 5; replace it by 232→246, rank 4, followed by 246→127, rank 1. Its contact-free interval is [36308,56318). Roles 472 and 1359 each have one rank 1 MOVE 246→127, at 44123 and 45185 respectively; delay them past the cut without changing their ranks. Their intervals are [44118,46149) and [44152,47585). + +The constructor checks every event and source read in these intervals, source/destination frames, actual nesting, distinct roles and exact old/new paid Counters. The two subdivisions compose to the old map because C_b C_f⁻¹ C_f C_a⁻¹=C_b C_a⁻¹, including absolute phase. Retiming across operations on other fields preserves the word. All paths are public. The owned labels shift by one for the fresh public input; their 54 lifetimes, peak 43 and 23 rises of mass 56 remain unchanged. + +## Independent retirement and continuation + +Let P be the retimed scalar prefix and S its suffix. The entire exact witness is small: + + a = c = e789ᵀ, + b = e789 + 8e1359 − 2e1205 + 2e472, + d = e789 − 2e299 + 4e1062 + 2e472. + +Exact rational replay verifies aP=c, Sb=d and ab=cd=1. Both c,d are supported on independent helpers with endpoints3→127. All fields in a,b, and pivot 236, actually occupy chart246 at the cut. The independent input represented by this mode is retained, not replaced by zero scratch. + +Ali Romman's attributed basis routine emits G at boundary 3 and J at cut 246, each using seven scalar instructions, with row236(G)=c, Gd=e236, row236(J)=a and Jb=e236. Both basis programs and their inverses satisfy the retained 2,3,5-smooth alphabet and scalar magnitude limit. Their four applications add 24 ADD and 4 SCALE instructions. No arbitrary rational division or uncharged basis operation is granted. + +Apply G⁻¹ before P and J after P. Coordinate 236 then equals its original independent input x236, since aPG⁻¹=cG⁻¹=e236ᵀ. Retire that coordinate at 246 and replace its continuation by a fresh independent input z. Apply J⁻¹ with the new role, continue S, and apply G at the full output boundary using that new role. The replacement changes the suffix by d(z−x236), which G maps to e236(z−x236). The complete source is identity on the entire helper group and has no coupling to its other inputs/outputs, so it commutes with G. Every other native endpoint is restored. This proof does not invert P or S and permits the retained owned initialization/erasure operations. + +The original pivot has target 3→246, rank 8. Fresh role 1486 has target 246→127, rank 1. The emitted word has 73,628 events and 1,487 public inputs. Its canonical hash is `cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3`. Separate forward and adjoint replays check all independent public inputs and owned rows. The physical and caller checks use this exact changed word. + +## Complete signed change + +Write H_r=r^(1−κ). Per native invocation, + + ΔP = H1 + H4 − H5, + ΔT = H1 + H8 − H9, + Δ(T−P) = H8 + H5 − H9 − H4. + +For 0<κ<1 the last expression is strictly positive: the increment H5−H4 exceeds H9−H8 by strict concavity. Both paid and target rank masses are unchanged. Across the unchanged 17-stage caller, ΔP={1:+17,4:+17,5:−17} and ΔT={1:+17,8:+17,9:−17}. The complete surplus remains 1424 and no empty-root credit appears. The exact engines recompute the full old and new invoices and reject the old invoice at the new claim. Numerical claims are not added together. + +All 28 added scalar instructions, the extra independent input, the one net added MOVE, native/caller odd conversions, fresh precision and physical routes enter APPLICATION.md. The fixed-invoice crossing is a ceiling for this invoice only. The five framework assumptions remain; independent mathematical review and maintainer admission are separate. + +Credit Ali Romman for the helper-basis identity and paid meetings; Jerry Chen/CubeJerry for causal retiming; Matarener for the complete discovery kernels and pairing decision; Rohan Arun for the 17-stage caller; ToikY, DreamingOfClouds, Douglas Colkitt/#7000 reviewers and every retained source author. The exact residual construction was prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-funded-residual-split/README.md b/research/p104-funded-residual-split/README.md new file mode 100644 index 0000000000..174bf9a63f --- /dev/null +++ b/research/p104-funded-residual-split/README.md @@ -0,0 +1,58 @@ +# Conditional κ 0.003639042931507 from a residual helper split + +This construction improves [#7117](https://github.com/CrocSwap/integer-mult-bounds/pull/7117) by **0.000000100498024**. On its exact native word, one paid rank-five move becomes rank four plus rank one. Two neutral retimings then expose another independent rank-nine helper, which splits into ranks eight and one. The complete paid and productive profiles change; the signed 17-stage caller remains unchanged. The selected frontier is unchanged. + +The conditional claim is `3639042931507/1000000000000000`. Both exact price engines reject #7117's invoice at this claim. The independent raw crossing is + +``` +(0.00363904293150729230234892845394584, + 0.00363904293150729230234892845394585). +``` + +This is the ceiling for the emitted invoice, with more than 0.9999999999999 of that ceiling realized. The retained BIT cap 0.00376669 leaves 0.000127647068493 headroom, without asserting that it is attainable. The older `complex-local-word-ceiling/ceiling.py` model assumes a hosted nine-stage template and its coverage law; this signed 17-stage caller has independent productive helper targets and does not satisfy those hypotheses. The complete signed-invoice crossing above is the applicable replacement bound, not a global bound on other words or callers. + +## Exact edit and full bill + +[PROOF.md](PROOF.md) gives the source-specific identity. At source cut 45209, chart 246, paid role 789 moves through the chart and roles 472 and 1359 delay their rank-one exits. Pivot 236 retires there; fresh role 1486 receives an independent arbitrary input. `WITNESS.json` contains all four short rational vectors and all three checked contact-free intervals. + +The word adds **24 ADDs, four SCALEs and one net MOVE**. It has 73,628 events, 1,487 public inputs, 1,087 independent helpers and 51 owned labels. All 54 owned lifetimes, peak 43 and 23 rises of mass 56 remain unchanged. Native odd scale 1125 and fractional height 24 are derived afresh from every prefix coefficient and pre-ADD product. Full source-unit ordinary work is **777,622,672 < 10⁹**. Fresh precision gives **c=2338**, context height 405 and mass exponent 1169. + +| Complete 17-stage invoice | #7117 | This construction | +|---|---:|---:| +| Paid positions |110672|110689| +| Productive fields |22206|22223| +| Rank surplus |1424|1424| +| Empty-root credits |0|0| + +The changes are ΔP={1:+17,4:+17,5:−17} and ΔT={1:+17,8:+17,9:−17}. The native signed gain is H8+H5−H9−H4, strictly positive for H_r=r^(1−κ), 0<κ<1, by concavity. Acceptance also requires the full ordinary, precision and outer gates, which are recomputed. + +## Source closure and reproduction + +The complete 25-file input export is [#7117](https://github.com/CrocSwap/integer-mult-bounds/pull/7117) at `092255ac8e9ed07ea59fee87c9711a5d72b10750`. Its unchanged nested exports retain #7116, #7115, #7112 and **Rohan Arun's [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113)** caller at `07a76c5e2738882c0cb322278e56f6cae3c9885d`, together with their complete predecessor sources and notices. `INPUTS.json` authenticates SHA256 and Git blob IDs before import. The replay reconstructs every source native byte before applying the new edit. + +Source native: `954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8`. + +Candidate native: `cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3`. + +Unchanged literal caller: `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-funded-residual-split +``` + +The first command authenticates and reconstructs the source and candidate, checks both arbitrary-input native orientations, derives the grid, and runs the full finite physical native and signed-child checks. It also prices the retained 18-stage ingredient caller; that receipt is distinct from the final 17-stage application. The second command reconstructs both complete 17-stage invoices, emits the unchanged literal caller and freshly checks all affected components. All **3,048 paid/helper chart maps and 104 main boundaries** receive signed-Pauli and absolute-phase checks. Four affected pairs additionally receive all 512 column checks in the native command, including the new 232→246 pair. + +Sixteen native corruption controls reject missing paths and corrections, wrong vectors or frames, unpaid subdivisions, incorrect path ranks, illegal contacts and insufficient grids. Phase, owner-alias, caller-grid and BIT controls remain active. Every frozen receipt field is compared. The standard-library replay requires neither Git nor network and rejects optimized Python. `--out UNUSED_PATH` writes a fresh receipt without overwriting a frozen one. [VALIDATION.md](VALIDATION.md) records completed runs and their limits. + +## Scope and predecessor credit + +[APPLICATION.md](APPLICATION.md) supplies the exact operator, owner/phase, grid, precision, physical upper-cost and fixed-tape substitutions. The five assumptions remain: `native_all_columns`, `owned_erasure`, `compiler`, `precision_tape`, `analytic_recovery`. Owned erasure retains its nonzero-content premise. Independent human/formal review and maintainer admission remain open. No compiled top-level multiplier or global optimum is claimed. + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. Apache-2.0. Credit **Ali Romman** for helper bases and paid meetings; **Jerry Chen/CubeJerry** for retiming and native/invoice/compiler engines; **Matarener** for complete discovery kernels and pairing; **Rohan Arun** for the 17-stage caller and application; **ToikY** and **DreamingOfClouds** for the native/signed lineage; **Douglas Colkitt and the #7000 reviewers** for the selected source-specific proof and BIT ambient-134 repair; and all retained predecessor authors and notices. The preceding dillona/OpenAI Codex #7105/#7107/#7112/#7115/#7116/#7117 contributions remain credited. ToikY's pending chart-120 rank-eight lead is distinct and is not claimed here. + +## Open next questions + +- Independently review this residual split and full application using the exact source export and registered replay. +- Can a distinct published edit compose with this word? Pin its exact artifact and replay the combined identity and complete costs; adding advertised profile gains is insufficient. + +The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521) records the bounded source change and overlap. `DISCOVERY.json` distinguishes the local nomination search from the public selected witness. No search optimum is asserted. diff --git a/research/p104-funded-residual-split/REPLAY.txt b/research/p104-funded-residual-split/REPLAY.txt new file mode 100644 index 0000000000..a1a0e1d575 --- /dev/null +++ b/research/p104-funded-residual-split/REPLAY.txt @@ -0,0 +1,73 @@ +CHECK Authenticate/reconstruct exact7117 from complete25-file export and nested closure; verify three retimed paths, arbitrary-input forward/adjoint, exact paid/target Counters, fresh grids and18-stage ingredient bill, precision, all512columns of4affectedmaps,16negativecontrols, full finite native/signed-route replay and every NATIVE-RESULT field. +PASS source reconstruction, whole cut, adjoint and independent forward map +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 signed caller, ordinary bill, two exact price engines, precision and compiler gates +events 73628 public 1487 owned roles 51 paid {1: 4033, 2: 841, 3: 817, 4: 238, 5: 326, 6: 16, 7: 12, 8: 6} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 16, 2: 18, 3: 46, 4: 217, 5: 71, 6: 42, 7: 18, 8: 58, 9: 601} +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 73628 events, 2963 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1087), 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 chart columns and phase, rejection controls and finite physical replay +PASS_P104_FUNDED_RESIDUAL_NATIVE 3638471460383/1000000000000000 +CHECK Reconstruct current7117 and candidate17-stage invoices, unchanged literal caller, all3048paid/helpermaps and104mainboundaries, fresh grids/envelopes, ordinary/physical/fixed-tape costs, two exact prices and54+4outer checks; compare every RESULT field. +PASS two reconstructed invoices and both exact price engines 0.003639042931507 +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 ['18195214657536461511744642269729/5000000000000000000000000000000000', '36390429315072923023489284539459/10000000000000000000000000000000000'] +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 110689 13600 22223 +RUN check_odd_precision.py +PASS short precision 405 1169 2338 +RUN check_odd_partial_admission.py +ordinary bill 777622672 +PASS partial signed short gates 777622672 3639042931507/1000000000000000 {'strict_count': 54, 'functional_count': 4, 'minimum_margin': '1/1000000000000000000', 'BIT_just_below_effective_rejected': True} +RUN check_odd_fixed_tape_counts.py +PASS finite tariff substitution 42261280 25465969408 precision 2338 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3048 +PASS complete 8+9 component application checks 3639042931507/1000000000000000 3048 110689 +PASS_P104_FUNDED_RESIDUAL_SPLIT 3639042931507/1000000000000000 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-funded-residual-split outcome=partial diff --git a/research/p104-funded-residual-split/RESULT.json b/research/p104-funded-residual-split/RESULT.json new file mode 100644 index 0000000000..3b69c963ce --- /dev/null +++ b/research/p104-funded-residual-split/RESULT.json @@ -0,0 +1,1545 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "6233a650df14a307a4094525c16fa1cfc09f6c50749f545b9ce2c72012663e9e", + "check_odd_precision.py": "65fc0858c70601fa3de6c758fa5b11388a5225bf813d1f383ac9aae26721e303", + "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(\".003639042931507\")", + "old": "claim=Q(\".00363797977\")" + }, + { + "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)\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": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "b15ce4ccb1f1620a4a13686db246fc9ed5937b614c5693297c9c514d726cfc39", + "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": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + }, + { + "catalogue_digest": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "c3905a6b7d6dd40cb63f001c90cda93c912426a6887aa7a2e5b7d6c34beae423", + "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": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + }, + { + "catalogue_digest": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1048, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "34fae455ec7fc7f3e5dbd548aee6ab1554c851637e2793e81e2a428f19d01686", + "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": 3048, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "3639042931507/1000000000000000", + "catalogue": [ + { + "catalogue_digest": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "b15ce4ccb1f1620a4a13686db246fc9ed5937b614c5693297c9c514d726cfc39", + "log_sha256": "6e5b6b0c1aff06682e868105529248ec5a48b83714a24f5684ebdc25632605f0", + "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": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + }, + { + "catalogue_digest": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "c3905a6b7d6dd40cb63f001c90cda93c912426a6887aa7a2e5b7d6c34beae423", + "log_sha256": "e83fa6397918d0f7954d682e7a0eaadff605d3d159678f24c16e115f7fcde340", + "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": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + }, + { + "catalogue_digest": "c46b6f41e99499c02b8919f7f309b5ab1845e8df0de0695a2ac934e72ddca87c", + "catalogue_size": 3048, + "checked_maps": 1048, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "34fae455ec7fc7f3e5dbd548aee6ab1554c851637e2793e81e2a428f19d01686", + "log_sha256": "dd767d5b3a89a53fda973358b9fcfa726050aee3cb0620963fe42f21b1b31088", + "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": 3048, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e" + } + ], + "fixed_tape_counts": { + "H": 16487800000000000000000, + "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": 2338, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25465969408, + "log_power": 2234, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298672, + "native_invocations": 17, + "native_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58046, + "native": 1144763 + }, + "scalar_services_upper": 42261280, + "scalar_steps_coefficient": 44314163937280, + "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": "3639042931507/1000000000000000" + }, + "native_archive_sha256": "387fd77169e619edf3fa1ebcecb899fa597b9b49100b631c1ac88a3c13727f4e", + "native_canonical_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "numeric_gate": { + "BIT_margin": "12764706849293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16487800000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3639042931507/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8999722359535816, + 0.8999722359535816 + ], + "derivative_upper": -382336.36232352705, + "gamma": [ + 0.9407515379293582, + 0.9407515379293582 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3639042931507/1000000000000000": [ + "124165168040325764653176950469841713276811090663599033372251147533874187148483/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124165168040325764653176950469841713276811090663599033372251147533874187150439/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "15520646005041006417649779192455389593456370584357805367855266217130375814123/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "24833033608065610268239646707928623349530192934972488588568425947408601302991/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2233, + "moment_margin_float": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + 1.6409432077881024e-29, + 1.6409432077881024e-29 + ], + "363904293150707/100000000000000000": [ + 8.634117937352138e-11, + 8.634117937352138e-11 + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + -2.2430094265274934e-29, + -2.2430094265274934e-29 + ] + }, + "moment_margins": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + "820471603894051140289776045397806824123577359657139/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "32818864155762045611591041815912272964943095163303/2000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "8634117937352138387978154857222265946844031252848076826378678573515771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4317058968676069193989077428611132973422015626424038413189339306299637/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + "-1121504713263746707032457084578618452136713036848683/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1121504713263746707032457084578618452136713017728889/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18195214657536461511744642269729/5000000000000000000000000000000000", + "36390429315072923023489284539459/10000000000000000000000000000000000" + ], + "tested": "363904293150707/100000000000000000", + "written_log_power": 2234 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "9dcd206de9f2fe8a5d8b547962e9f1fafffeec522023aa802e70af28b9b3aa04", + "fresh_helpers": 18479, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1487, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68945, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4046, + "40": 416, + "48": 416, + "5": 5542, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "paid_positions": 110689, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22223, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 986, + "9": 10633 + } + }, + "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": 777622672, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222377328, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2629016, + "raw_upper": 760985496, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2174, + "moves": 6289, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9879000, + "scalar_upper": 1988480 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12764706849293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16487800000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3639042931507/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8999722359535816, + 0.8999722359535816 + ], + "derivative_upper": -382336.36232352705, + "gamma": [ + 0.9407515379293582, + 0.9407515379293582 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3639042931507/1000000000000000": [ + "124165168040325764653176950469841713276811090663599033372251147533874187148483/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124165168040325764653176950469841713276811090663599033372251147533874187150439/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "15520646005041006417649779192455389593456370584357805367855266217130375814123/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "24833033608065610268239646707928623349530192934972488588568425947408601302991/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2233, + "moment_margin_float": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + 1.6409432077881024e-29, + 1.6409432077881024e-29 + ], + "363904293150707/100000000000000000": [ + 8.634117937352138e-11, + 8.634117937352138e-11 + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + -2.2430094265274934e-29, + -2.2430094265274934e-29 + ] + }, + "moment_margins": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + "820471603894051140289776045397806824123577359657139/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "32818864155762045611591041815912272964943095163303/2000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "8634117937352138387978154857222265946844031252848076826378678573515771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4317058968676069193989077428611132973422015626424038413189339306299637/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + "-1121504713263746707032457084578618452136713036848683/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1121504713263746707032457084578618452136713017728889/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18195214657536461511744642269729/5000000000000000000000000000000000", + "36390429315072923023489284539459/10000000000000000000000000000000000" + ], + "tested": "363904293150707/100000000000000000", + "written_log_power": 2234 + }, + "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": 68945, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4046, + "40": 416, + "48": 416, + "5": 5542, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 986, + "9": 10633 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036390429315072923023489284539458422493104908128824429318160706633", + "raw_crossing": "0.0036390429315072923023489284539458422493104908128824429318160706633" + }, + "native_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "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": 777622672, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222377328, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2629016, + "raw_upper": 760985496, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2174, + "moves": 6289, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9879000, + "scalar_upper": 1988480 + }, + "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": 16487800000000000000000, + "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": 2338, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25465969408, + "log_power": 2234, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298672, + "native_invocations": 17, + "native_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58046, + "native": 1144763 + }, + "scalar_services_upper": 42261280, + "scalar_steps_coefficient": 44314163937280, + "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": "3639042931507/1000000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "9dcd206de9f2fe8a5d8b547962e9f1fafffeec522023aa802e70af28b9b3aa04", + "fresh_helpers": 18479, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1487, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68945, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4046, + "40": 416, + "48": 416, + "5": 5542, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "paid_positions": 110689, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22223, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 272, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 986, + "9": 10633 + } + }, + "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": 2338, + "context_height": 405, + "context_mass_bits": 1169, + "native_grid": { + "coefficient_visits": 14988301, + "dyadic_height": 24, + "mass_witness": [ + 64684, + "stored add" + ], + "maximum_scaled_mass": "1630603680282225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "precision_program_sha256": "7696f2e4074ccc9c970670494595e2a973742279a6109d1e60fd551a4611d236", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "698024287251651901803459951862316597879600742244909895539710639042158344540894841563656646982053691114958279303174698887618504400122312767734397762395919825381405683025129132428133455772355464043977320251080664406740469406000911275502666303804265009860426045515839025717762213952516115168758148934507637533094625747991528699552446582408599277121402828667947509018317069668745753830964309138239256958842104744186069306061/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1132, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "18014333085046828956241650991134168885407248226674624576663993922657927915915154260252294247959126415554943003520885980524904629352392394215005002626574522409641264615072574524955274534207747344617748024843520049413561681908525038787988437514954365807605043949377615635758702574529747122801699391370623153303968329914337792347928821856045076588211139725089777945998122592308316328973350748637311646187053012112224781720431/14819286409447601382767571920486400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1137, + "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": "251563092290165301358965641021901831160856265157714243970693723428697194571190801847757910472840054539145907305347689298588906864307571000778653319298264875821043945057286578411943970864033189282411459001350050512364253877019535861267942504463220341750498404315825605197732516381266677208581990276044749535999213352454730973551658471501709085206596955050010499010276220214321852508620099252176274958104668679383060318105785477/105381592244960720944124955879014400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1148, + "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": "18014333085046828956241650991134168885407248226674624576663993922657927915915154260252294247959126415554943003520885980524904629352392394215005002626574522409641264615072574524955274534207747344617748024843520049413561681908525038787988437514954365807605043949377615635758702574529747122801699391370623153303968329914337792347928821856045076588211139725089777945998122592308316328973350748637311646187053012112224781720431/14819286409447601382767571920486400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1137, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "14108139091270573653637837415924127043280686673336063693876650683972020511516865919235037424330262112339674182550221217296160143881875299109676633711996980840587987743391094157662366998344094830348430132523164757272167158570182439624839987680692433486318046875523055539314917218917748998744222831832476851831748922302087377229490717385162554978663647232204026917109043806975539237534963929321237310157402478239668168366042810638856891390977334192022569742409159454441947942698594342964839853041982831682095938245039741869945703999214572701986527791807/3423689690092006159733108133936318139518312371955275640514963046400000000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1388, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18479, + "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": "698024287251651901803459951862316597879600742244909895539710639042158344540894841563656646982053691114958279303174698887618504400122312767734397762395919825381405683025129132428133455772355464043977320251080664406740469406000911275502666303804265009860426045515839025717762213952516115168758148934507637533094625747991528699552446582408599277121402828667947509018317069668745753830964309138239256958842104744186069306061/19759048545930135177023429227315200000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "18014333085046828956241650991134168885407248226674624576663993922657927915915154260252294247959126415554943003520885980524904629352392394215005002626574522409641264615072574524955274534207747344617748024843520049413561681908525038787988437514954365807605043949377615635758702574529747122801699391370623153303968329914337792347928821856045076588211139725089777945998122592308316328973350748637311646187053012112224781720431/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "18014333085046828956241650991134168885407248226674624576663993922657927915915154260252294247959126415554943003520885980524904629352392394215005002626574522409641264615072574524955274534207747344617748024843520049413561681908525038787988437514954365807605043949377615635758702574529747122801699391370623153303968329914337792347928821856045076573391853315642176563230550671821916328973350748637311646187053012112224781720431/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "698024287251651901803459951862316597879600742244909895539710639042158344540894841563656646982053691114958279303174698887618504400122312767734397762395919825381405683025129132428133455772355464043977320251080664406740469406000911275502666303804265009860426045515839025717762213952516115168758148934507637533094625747991528699552446582408599277121402828667947509018317069668745753830964309138239256958842104744186069306061/19759048545930135177023429227315200000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "18014333085046828956241650991134168885407248226674624576663993922657927915915154260252294247959126415554943003520885980524904629352392394215005002626574522409641264615072574524955274534207747344617748024843520049413561681908525038787988437514954365807605043949377615635758702574529747122801699391370623153303968329914337792347928821856045076588211139725089777945998122592308316328973350748637311646187053012112224781720431/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "8302671765282496157415868430822597258526922507742103638903443184497403353265112032543032757225369393193344334378322249000353923668571/423027322799551040813185105920000000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "12615013309201778647169995657788155167372358416023783446335548442040975509301320562681715703761897947402173754448487443326471383584608354969211611/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "11749680755356295724456691508250414354558885186663587938324176345241688141705902718685556502866043216960115578265522182209372309436615359762944834524423323/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "2400194433360333633550664161944532049414801093198142176245566263753712014272697713737608463242482993121987052989401402223515137850981939738862359571421452627415516733/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "229818579907222232177233722790880445104801835250438406523806940243154262658776062810020759550490445300236870747481087221427509384793001224359393511783950545638402645348951671897/609159344831353498770986552524800000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "24511324765078159858973405334784320951412572665697308069209674908050683590565835644991144683786475563902010900888393977106832972080634275090935322171026688848862038478341815734273165731447/67684371647928166530109616947200000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "7136702343604286030286480672522350444747244327660979769425054989264391305977148446229981303866194285741352206526839650464972236190554687978556663382946276074636429024297097876773099065695967743321994549713/76144918103919187346373319065600000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "2545110471451614632086508652453611872197751579414900617472430223200071502721357760126437274080893854841278528132246960989515473901279068902596852270379128875054307426714150317661738828260283878642128539078719109174964017266115888042829845272096761816570640549175678367471532199966499352569677989632909051856732366627619416245797055994026773/87817993537467267453437463232512000000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "967781792021211669859073596478657018600565080600681027264867703956776795703716945951293178965675554489474359794251065834299679293850162260791245131476958757846880772152284303567815127843630837468910480253754360688723901233272997704368263269093321362077136326183162207684307975252564181965354708928599314422759116020495285430931324294319812406993602394167/2195449838436681686335936580812800000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "461714954961579655667587937744025343509762713855740337847499768595623576008619483537841661660365681856996026236300898935689452367068866070288889885125190078026260281157114502300836040232353932645841532980408835345396489166790982370723073556787891372450688491883050968804339366385780040362725192038807225831237835025177004719454477979897981345826334170080956545418573/73181661281222722877864552693760000000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "5802100833378026272896358305206953989514423024189484555381443497086965499073817411380011150256480349449594954840593061758298178644927148632250963427512577129703959665362264589396001924842102192170334512958516164084039739910599242771989671152687871915142826474320641974993371627529323599313523305793277282490023738624909403692927848328077775767356801699832730534919898377290864621/9879524272965067588511714613657600000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "382180690035498777149441994048937392236122058242449675329349421204057421792850586907218805155165007097711808770147577164763109638007444013876500385365392375227271518974693712768533726614625727265454685368887833284321001469725863061036009893228535486280053000055393062370297287472111330198144379170330302418287180265579434295311938599316567922672635345040686902317549325681257744369714349/2469881068241266897127928653414400000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "15348977850450470907562293530233771277386725648651213277450839400006999580551715674569720017692757145225395434889602790410790428806105177083933631580399445127709065099199140579109815736743032803286403958543096686057035647601777795791686619156551412984917002677565574231656417834928098264798656857900227014549998826478344710565043158900684081081452616793007117814970392993087101391170518132869084981/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "293352175078815555148826301561243378468696520373638881798293985234309793829119087977805632372795570081024177078369004017481966768734579189430333254540103951482762031006035851343732597534611937249372463432970039693050848641989894935256577685693903785878152845239198881581398861310378533693690336736840775714502621227281321325031687951127429937412942234436958668505809403192490780259307142934082372768259751/9879524272965067588511714613657600000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "324738052258432259602352029679196596468153125307988594610724207103486867984210563009935515374238192974112607558531018915720667637059327366347915121996955468852356229659478245865472879423881825056528869910255397657095530659682152960406769210165538382230376853083741903337060851616455256552863715231667264025650710064996194334138825766387124346360463514320782703221718925410559516341637178881352384275895984928018333/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "698024287251651901803459951862316597879600742244909895539710639042158344540894841563656646982053691114958279303174698887618504400122312767734397762395919825381405683025129132428133455772355464043977320251080664406740469406000911275502666303804265009860426045515839025717762213952516115168758148934507637533094625747991528699552446582408599277121402828667947509018317069668745753830964309138239256958842104744186069306061/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "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": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 73628, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 257, + "witness": { + "cut": 72908, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 72908, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73628, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63548, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6289, + "SCALE": 3682 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1487, + "scalars": { + "dyadic": 61945, + "integer": 39244, + "noninteger": 27987, + "odd": 5286 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + }, + "M": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26056, + "entrance_mass": "20211530385022697059663281519169642296537491362687916349167980440418743497102771988018812895561858711458967941088802115329191494587/173271991418696106317080619384832000000000000000000000", + "residual_mass": "4840059394232678400761958200486879940752790741638633653065099527107796197406689427906923562042926399657613707101767830608336053/1353687432958563330602192338944000000000000000000000" + } + } + }, + "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": 68945, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4046, + "40": 416, + "48": 416, + "5": 5542, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "raw_bracket": [ + "18195214657536461511744642269729/5000000000000000000000000000000000", + "36390429315072923023489284539459/10000000000000000000000000000000000" + ], + "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": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "target": { + "1": 272, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 986, + "9": 10633 + } + } + }, + "claim": "3639042931507/1000000000000000", + "price": { + "after": { + "P": { + "1": 68945, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4046, + "40": 416, + "48": 416, + "5": 5542, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 272, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 986, + "9": 10633 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036390429315072923023489284539458422493104908128824429318160706633", + "raw_crossing": "0.0036390429315072923023489284539458422493104908128824429318160706633" + }, + "before": { + "P": { + "1": 68928, + "16": 416, + "2": 14297, + "24": 416, + "3": 13889, + "32": 416, + "4": 4029, + "40": 416, + "48": 416, + "5": 5559, + "56": 416, + "6": 272, + "64": 208, + "7": 204, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 255, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 782, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1207, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 969, + "9": 10650 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036389424334832642636059645307555961401460449778468130733429304035", + "raw_crossing": "0.0036389424334832642636059645307555961401460449778468130733429304035" + }, + "gate": { + "BIT_margin": "12764706849293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16487800000000000000000", + "alpha": [ + 0.9999999999999997, + 0.9999999999999997 + ], + "claim": "3639042931507/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8999722359535816, + 0.8999722359535816 + ], + "derivative_upper": -382336.36232352705, + "gamma": [ + 0.9407515379293582, + 0.9407515379293582 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3639042931507/1000000000000000": [ + "124165168040325764653176950469841713276811090663599033372251147533874187148483/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124165168040325764653176950469841713276811090663599033372251147533874187150439/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "15520646005041006417649779192455389593456370584357805367855266217130375814123/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "24833033608065610268239646707928623349530192934972488588568425947408601302991/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2233, + "moment_margin_float": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + 1.6409432077881024e-29, + 1.6409432077881024e-29 + ], + "363904293150707/100000000000000000": [ + 8.634117937352138e-11, + 8.634117937352138e-11 + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + -2.2430094265274934e-29, + -2.2430094265274934e-29 + ] + }, + "moment_margins": { + "18195214657536461511744642269729/5000000000000000000000000000000000": [ + "820471603894051140289776045397806824123577359657139/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "32818864155762045611591041815912272964943095163303/2000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363904293150707/100000000000000000": [ + "8634117937352138387978154857222265946844031252848076826378678573515771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4317058968676069193989077428611132973422015626424038413189339306299637/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36390429315072923023489284539459/10000000000000000000000000000000000": [ + "-1121504713263746707032457084578618452136713036848683/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1121504713263746707032457084578618452136713017728889/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18195214657536461511744642269729/5000000000000000000000000000000000", + "36390429315072923023489284539459/10000000000000000000000000000000000" + ], + "tested": "363904293150707/100000000000000000", + "written_log_power": 2234 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "cbce61015e22007f785474e2af2462a7d97ead1e105d71cd2d9cbc0a449580f3", + "old_native": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "3903296457040941296096080655147684454780824879821426970732914040081468604405337/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "3903296457040941296096080655147684454780824879821426970732914040081468638779197/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003639042931507", + "gain": "1.00498024E-7", + "gain_exact": "12562253/125000000000000", + "independent_raw_bracket": [ + "0.00363904293150729230234892845394584", + "0.00363904293150729230234892845394585" + ], + "previous_claim": "3638942433483/1000000000000000", + "raw_bracket": [ + "0.0036390429315072923023489284539458", + "0.0036390429315072923023489284539459" + ] + } + }, + "status": "PASS_P104_FUNDED_RESIDUAL_SPLIT" +} diff --git a/research/p104-funded-residual-split/SOURCES.json b/research/p104-funded-residual-split/SOURCES.json new file mode 100644 index 0000000000..c4150ae397 --- /dev/null +++ b/research/p104-funded-residual-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-funded-residual-split/TASK.json b/research/p104-funded-residual-split/TASK.json new file mode 100644 index 0000000000..a9dd5d2251 --- /dev/null +++ b/research/p104-funded-residual-split/TASK.json @@ -0,0 +1,138 @@ +{ + "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": "The exact7117 paid contact word differs from the closed7115 scopes. Its two paid subdivisions expose a residual helper mode with one further fully charged rank5 subdivision.", + "concrete_question": "Does residual rank9 capacity on exact7117 improve its complete signed17-stage invoice?", + "actual_scope": "Sourcecut45209/chart246/pivot236; paid role789 rank5-to-4+1 and neutral rank1 retimings472,1359;24ADD+4SCALE+1netMOVE; helper9-to-8+1.", + "domain": "One exact current native word, contact-free retimings and the existing scalar alphabet; complete signed17 application.", + "success": "Both arbitrary-input native orientations, exact phase, complete full caller paid/target/ordinary/grid/envelope/fixed-tape substitutions and both directed conditional gates beat7117.", + "bottleneck_link": "The previous funded meeting changes cut capacity. All further paid transport and precision must be charged.", + "predecessor_head": "092255ac8e9ed07ea59fee87c9711a5d72b10750", + "predecessors": [ + "Ali Romman: helper bases, independent split identity and paid meetings", + "Jerry Chen/CubeJerry: causal retiming, native/invoice/compiler engines", + "Matarener: complete kernels including zero boundary images and pairing decision", + "Rohan Arun: exact7113 signed17-stage caller and source-specific application", + "ToikY:7108-7110 signed sources and splits; distinct chart120 lead remains unclaimed", + "DreamingOfClouds, Douglas Colkitt/#7000 reviewers and all retained nested-source notices", + "dillona/OpenAI Codex:7105,7107,7112,7115,7116,7117; exact7117 parent retains all earlier exports" + ], + "outcome": "completed", + "evidence_status": "Both complete direct CPython3.14.7 runs and final isolated registered CPython3.12.16 replay passed. All frozen native and composition receipt fields matched, including16nativecontrols,3048paid/helpermaps,104mainboundaries and54+4outer checks.", + "evidence": "WITNESS.json, WORD.json.gz, INPUTS.json, NATIVE-RESULT.json, RESULT.json and REPLAY.txt when completed.", + "overlap": "Canonical main e545/priority8/selected7000 unchanged at18:43UTC. Refreshed complete pagination covers417openPRs at18:43:26UTC and7022Discussionrecords at18:44:31UTC. Peer7111 reply19526102 identifies distinct chart120 rank8 work. This scope extends exact7117 rank9 word, not the peer lead.", + "open_questions": [ + { + "question": "Can an independent reviewer verify the fully charged residual split and complete application?", + "why_it_matters": "The local capacity pairing alone does not establish the conditional exponent.", + "first_step": "Run the registered Python3.12 replay and inspect PROOF.md and APPLICATION.md against the exact source closure.", + "blocked_by": "Independent review and maintainer admission remain separate." + }, + { + "question": "Can a distinct published native edit compose with this exact word?", + "why_it_matters": "Different cuts may interact through their corrective bases; profile addition alone is insufficient.", + "first_step": "Pin a public artifact, replay its identity on this exact word and recompute the whole application.", + "blocked_by": "No further edit or extrapolated gain is claimed." + } + ], + "stop_rule": "One new fully checked invoice; refresh before any further research round." +} diff --git a/research/p104-funded-residual-split/VALIDATION.md b/research/p104-funded-residual-split/VALIDATION.md new file mode 100644 index 0000000000..074ba6e00c --- /dev/null +++ b/research/p104-funded-residual-split/VALIDATION.md @@ -0,0 +1,14 @@ +# Validation record + +Both direct CPython 3.14.7 commands passed from authenticated source reconstruction: + +```sh +python3 -I -B research/p104-funded-residual-split/verify_native.py --out research/p104-funded-residual-split/NATIVE-RESULT.json +python3 -I -B research/p104-funded-residual-split/verify.py --out research/p104-funded-residual-split/RESULT.json +``` + +The native command passed the exact source/candidate reconstruction, full arbitrary-input forward and adjoint endpoints, declared paid/target deltas, fresh grid and precision, both ingredient price engines, all 16 rejection controls, four 512-column chart checks including absolute phase, full finite native execution and signed routes. The composition passed both complete 17-stage invoices and price engines, the unchanged rational/integer Laurent caller, owner/phase occurrence binding, fresh grids/envelopes, source-unit ordinary and physical fixed-tape costs, all 3,048 paid/helper maps and 104 main boundaries, and 54 strict + 4 functional outer conditions. + +Final registered isolated CPython 3.12.16 replay passed both complete commands and matched every frozen native and composition receipt field. REPLAY.txt preserves the actual stdout; the process exited successfully. The metadata outcome was marked completed afterwards, which explains outcome=partial in the captured runner line. No scientific code or receipt changed after that comparison. No Lean, Docker or concurrent artifact-regenerating suites were used. No hosted scientific pass is claimed. The predecessor #7117 workflow failed canonical onboarding because the CI guide names #6030 while the selected record names #7000; its scientific job was skipped. That external status is separate from this package's local scientific checks. + +The exploratory search nominated 17 witnesses with one common profile. Two complete native candidates were checked; only index 5, cut 45209, is submitted, with 28 scalar instructions versus 32 for the other tested candidate. The other 15 nominations were not constructed. No exhaustive cost optimization or independent human/formal review is claimed. The five assumptions, maintainer admission and compiled top-level execution remain obligations. diff --git a/research/p104-funded-residual-split/VERIFY.json b/research/p104-funded-residual-split/VERIFY.json new file mode 100644 index 0000000000..0f09718ef4 --- /dev/null +++ b/research/p104-funded-residual-split/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_native.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate/reconstruct exact7117 from complete25-file export and nested closure; verify three retimed paths, arbitrary-input forward/adjoint, exact paid/target Counters, fresh grids and18-stage ingredient bill, precision, all512columns of4affectedmaps,16negativecontrols, full finite native/signed-route replay and every NATIVE-RESULT field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Reconstruct current7117 and candidate17-stage invoices, unchanged literal caller, all3048paid/helpermaps and104mainboundaries, fresh grids/envelopes, ordinary/physical/fixed-tape costs, two exact prices and54+4outer checks; compare every RESULT field." + } + ] +} diff --git a/research/p104-funded-residual-split/WITNESS.json b/research/p104-funded-residual-split/WITNESS.json new file mode 100644 index 0000000000..25f1927d24 --- /dev/null +++ b/research/p104-funded-residual-split/WITNESS.json @@ -0,0 +1,98 @@ +{ + "frame": 246, + "pivot": 236, + "cut": 45209, + "ranks": [ + 8, + 1 + ], + "gain": 0.00229605673943567, + "paths": [ + { + "role": 789, + "lo": 36308, + "hi": 56318, + "frame": 246, + "old": 232, + "new": 127, + "moves": [ + 44678 + ], + "old_paid": [ + 5 + ], + "new_paid": [ + 4, + 1 + ], + "cost": 0.009069905710861192, + "private": false, + "neutral": false + }, + { + "role": 472, + "lo": 44118, + "hi": 46149, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 44123 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 1359, + "lo": 44152, + "hi": 47585, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 45185 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + } + ], + "a": { + "789": "1" + }, + "b": { + "1359": "8", + "789": "1", + "1205": "-2", + "472": "2" + }, + "c": { + "789": "1" + }, + "d": { + "789": "1", + "299": "-2", + "1062": "4", + "472": "2" + }, + "paid_delta": { + "1": 1, + "4": 1, + "5": -1 + } +} diff --git a/research/p104-funded-residual-split/WORD.json.gz b/research/p104-funded-residual-split/WORD.json.gz new file mode 100644 index 0000000000..cbf5332c85 Binary files /dev/null and b/research/p104-funded-residual-split/WORD.json.gz differ diff --git a/research/p104-funded-residual-split/adapt.py b/research/p104-funded-residual-split/adapt.py new file mode 100644 index 0000000000..4ef7a4b670 --- /dev/null +++ b/research/p104-funded-residual-split/adapt.py @@ -0,0 +1,27 @@ +"""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(".003639042931507")') + 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)\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-funded-residual-split/construct.py b/research/p104-funded-residual-split/construct.py new file mode 100644 index 0000000000..748bfe2be2 --- /dev/null +++ b/research/p104-funded-residual-split/construct.py @@ -0,0 +1,46 @@ +"""Checked simultaneous contact-free retiming, then attributed helper split. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +Extends #7105/#7107 retiming to an arbitrary finite cohort with an +exact declared total paid-histogram change; retains Ali Romman and CubeJerry split. +The complete signed invoice, not path cardinality, decides acceptance. +""" +from copy import deepcopy +from collections import Counter +from split import split +from support import L + +def prepare(word,hit): + paths=hit['paths'];L.need(1<=len(paths),'A nonempty finite retiming cohort') + L.need(len({p['role']for p in paths})==len(paths),'Distinct retimed roles') + f,cut=hit['frame'],hit['cut'];spaces=[L.span(x)for x in word['frames']];remove=set();paid_change=Counter() + for p in paths: + r,a,b=p['role'],p['old'],p['new'] + L.need(p['frame']==f and p['lo']<=cut<=p['hi'],'Cut in declared interval') + actual=[i for i in range(p['lo'],p['hi'])if word['program'][i][1]==r] + L.need(actual==p['moves'],'Every role event in interval is a relocated MOVE') + L.need(all(not(e[0]in('ADD','COPY')and e[2]==r)for e in word['program'][p['lo']:p['hi']]),'No intervening source read') + path=[word['program'][i]for i in actual] + L.need(path and all(e[0]=='MOVE'and e[1]==r and e[4]==p['private']for e in path),'Only MOVE events') + L.need(path[0][2]==a and path[-1][3]==b and all(x[3]==y[2]for x,y in zip(path,path[1:])),'Complete path') + L.need(spaces[a]<=spaces[f]<=spaces[b]or spaces[b]<=spaces[f]<=spaces[a],'Nested intermediate frame') + old_paid=Counter(abs(len(word['frames'][e[2]])-len(word['frames'][e[3]])) for e in path if spaces[e[2]]!=spaces[e[3]]) + new_paid=Counter(abs(len(word['frames'][x])-len(word['frames'][y])) for x,y in ((a,f),(f,b)) if spaces[x]!=spaces[y]) + L.need(old_paid==Counter(p['old_paid']) and new_paid==Counter(d for d in p['new_paid'] if d), 'Exact old and new path histogram declarations') + paid_change.update(new_paid);paid_change.subtract(old_paid) + L.need(not(remove&set(actual)),'Distinct removed events');remove.update(actual) + L.need({r:c for r,c in paid_change.items() if c}=={int(r):c for r,c in hit['paid_delta'].items()}, 'Entire declared retiming paid delta') + program=[];split_cut=None + for i in range(len(word['program'])+1): + if i==cut: + for p in paths: + if p['old']!=f:program.append(['MOVE',p['role'],p['old'],f,p['private']]) + split_cut=len(program)-1 + for p in paths: + if f!=p['new']:program.append(['MOVE',p['role'],f,p['new'],p['private']]) + if ipeak: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-funded-residual-split/inputs/pr7117.tar b/research/p104-funded-residual-split/inputs/pr7117.tar new file mode 100644 index 0000000000..8709147ce8 Binary files /dev/null and b/research/p104-funded-residual-split/inputs/pr7117.tar differ diff --git a/research/p104-funded-residual-split/price.py b/research/p104-funded-residual-split/price.py new file mode 100644 index 0000000000..283a3edfb1 --- /dev/null +++ b/research/p104-funded-residual-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 current #7117 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-funded-residual-split/source.py b/research/p104-funded-residual-split/source.py new file mode 100644 index 0000000000..1dab884d9e --- /dev/null +++ b/research/p104-funded-residual-split/source.py @@ -0,0 +1,56 @@ +"""Authenticate #7117'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 #7117 export') + old_path=list(sys.path) + with tempfile.TemporaryDirectory(prefix='p104-funded-residual-source-') as tmp: + root=Path(tmp);pins={x['path']:x for x in pin['files']};seen=set() + with tarfile.open(archive) as tar: + for member in tar: + if member.isdir():continue + path=root/member.name + need(member.isfile() and member.name in pins and member.name not in seen and path.resolve().is_relative_to(root.resolve()),'Unique safe listed source member') + raw=tar.extractfile(member).read();p=pins[member.name] + need(len(raw)==p['size'] and sha256(raw).hexdigest()==p['sha256'] and sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==p['git_blob'],'Exact source Git blob and SHA256') + path.parent.mkdir(parents=True,exist_ok=True);path.write_bytes(raw);seen.add(member.name) + need(seen==set(pins),'Complete source inventory') + parent=root/pin['prefix'];imports=load('residual_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('residual_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('residual_native_parent_construct',parent/'construct.py') + word=emitter.construct(word,read(parent/'WITNESS.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 #7117 native byte') + need(sha256(canonical(word)).hexdigest()=='954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8','Exact current native') + yield vendor,archive,rank9,bundle,parent,word diff --git a/research/p104-funded-residual-split/split.py b/research/p104-funded-residual-split/split.py new file mode 100644 index 0000000000..5407e8959b --- /dev/null +++ b/research/p104-funded-residual-split/split.py @@ -0,0 +1,154 @@ +"""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. +Successor: dillona/OpenAI Codex choose a small smooth swap entry when pivot is zero. +""" +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) 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-funded-residual-split/support.py b/research/p104-funded-residual-split/support.py new file mode 100644 index 0000000000..192cd38d27 --- /dev/null +++ b/research/p104-funded-residual-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,'Complete conservative ordinary bill') + gate,price=G.exact_price(vendor,archive,before,invoice,previous) + manifest=read(vendor/'INDEPENDENT-SOURCES.json') + P=load('static_bit_binding',archive/'verify.py');P.bit_binding(I,manifest) + precision=base.precision(vendor,word,caller,gate,manifest) + need(precision['word']['odd_scale_lcm']==1125 and precision['word']['dyadic_height']==24,'Recomputed signed caller precision') + print('PASS full signed caller, ordinary bill, two exact price engines, precision and compiler gates',flush=True) + charts=chart_check(vendor,source,word) + controls={} + grid_engine=G.module('static_grid_controls',vendor/'retained/odd-native-common-grid/independent_bounds.py') + controls['insufficient_odd_grid']=rejected(lambda:grid_engine.word_run(word,375,24)) + controls['insufficient_fractional_grid']=rejected(lambda:grid_engine.word_run(word,1125,23)) + bad=deepcopy(hit);bad['a']['789']='2' + controls['wrong_prefix']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['b']['789']='2' + controls['wrong_suffix']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['frame']=734 + controls['wrong_cut_frame']=rejected(lambda:construct(source,bad)) + from split import basis + Gbasis=basis(*[{int(k):Q(v)for k,v in hit[s].items()}for s in('c','d')],hit['pivot'],3) + Jbasis=basis(*[{int(k):Q(v)for k,v in hit[s].items()}for s in('a','b')],hit['pivot'],246) + need((len(Gbasis),len(Jbasis))==(7,7),'Boundary and cut basis lengths') + prepared,spec=prepare(source,hit) + split_after=spec['cut_after'] + for name,index in [('missing_cut_correction',len(Gbasis)+split_after+1), + ('missing_successor_correction',len(Gbasis)+len(Jbasis)+split_after+1)]: + bad=deepcopy(word);bad['program'].pop(index) + controls[name]=bool(I.native(bad)['bad_inputs']) + for role in (789,472,1359): + bad=deepcopy(hit);bad['paths']=[p for p in bad['paths'] if p['role']!=role] + controls['missing_retiming_'+str(role)]=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['paths'][0]['lo']-=1 + controls['intervening_scalar_contact']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['paths'][0]['moves']=[] + controls['omitted_old_move']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['paths'].append(deepcopy(bad['paths'][0])) + controls['duplicate_retimed_role']=rejected(lambda:construct(source,bad)) + bad=deepcopy(word);bad['initial'][-1]=3 + controls['wrong_successor_frame']=rejected(lambda:I.native(bad)) + bad=deepcopy(hit);bad['paid_delta']={} + controls['unpaid_subdivisions']=rejected(lambda:prepare(source,bad)) + bad=deepcopy(hit);bad['paths'][0]['new_paid']=[2] + controls['wrong_declared_path_ranks']=rejected(lambda:prepare(source,bad)) + need(all(controls.values()),'All split rejection controls') + physical_checks=[]; signed_routes=None + if physical: + with tempfile.TemporaryDirectory(prefix='static-physical-') as tmp: + path=Path(tmp)/'word.json.gz';path.write_bytes(gzip.compress(canonical(word),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) + physical_engine=G.module('static_signed_routes',rank9/'physical_child.py',( + ('cca66a7ec924bab47ccd1410968d16e071a01dc6110b5c08040bd207f753d066',sha256(canonical(word)).hexdigest()),)) + capture=io.StringIO() + with contextlib.redirect_stdout(capture):physical_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 route replay') + need(1000*sum(len(row['caller_fields'])*row['ordinary_elementary_units'] for row in signed_routes['bindings'])==routes==1168000,'Actual signed route ordinary charge') + physical_checks.append('physical_child.py') + print('PASS chart columns and phase, rejection controls and finite physical replay',flush=True) + return encode(dict(status='PASS_P104_FUNDED_RESIDUAL_NATIVE',source_head='092255ac8e9ed07ea59fee87c9711a5d72b10750', + word_canonical_sha256=sha256(canonical(word)).hexdigest(),native=native,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=['Source-aware reuse of attributed engines, not independent human or kernel review.', + 'The five framework assumptions remain; the current17-stage application is checked separately by verify.py.', + 'Finite physical checks and source-unit bills do not constitute a complete multiplication theorem.'])) + +def main(): + p=argparse.ArgumentParser();p.add_argument('--out',type=Path);p.add_argument('--skip-physical',action='store_true');a=p.parse_args() + result=run(not a.skip_physical) + if a.out: + with a.out.open('x') as f:json.dump(result,f,sort_keys=True,indent=2);f.write('\n') + else:need(result==read(HERE/'NATIVE-RESULT.json'),'Every frozen receipt field') + print(result['status'],result['gate']['claim'],flush=True) +if __name__=='__main__':main()