diff --git a/research/p104-funded-cohort-split/APPLICATION.md b/research/p104-funded-cohort-split/APPLICATION.md new file mode 100644 index 0000000000..f549ac1363 --- /dev/null +++ b/research/p104-funded-cohort-split/APPLICATION.md @@ -0,0 +1,29 @@ +# Conditional application to the funded native and signed caller + +This applies Rohan Arun's #7113 component proof and #7116's changed-native adaptation to the new funded 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. Two rank-two moves are subdivided into four rank-one moves, with every new occurrence charged. 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,047 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,672 paid positions and 22,206 productive fields. Main-owner aliasing is rejected. Allocate 18,462 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,486 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 1168, giving c=2336. This exceeds #7116's allowance 2328 and is recomputed rather than copied. 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=16480300000000000000000. 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,561,336 includes the caller and native conversion services. It is distinct from the physical-machine bound. The fresh raw-occurrence counts give 1,144,287 native scalar macro inputs, 117,856 caller macro inputs and 58,012 conversions. The retained conservative factor 32 gives 42,244,960 scalar services; with the reviewed 2²⁰ service constant this is 44,297,051,176,960 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,604 monomial map slots. At actual ambient 145, the retained elementary bound 4(145+1)² is 85,264 records per map, hence at most 25,460,171,456 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 private 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 paid-cohort construction by dillona with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-funded-cohort-split/DISCOVERY.json b/research/p104-funded-cohort-split/DISCOVERY.json new file mode 100644 index 0000000000..df29aa9426 --- /dev/null +++ b/research/p104-funded-cohort-split/DISCOVERY.json @@ -0,0 +1,165 @@ +{ + "systems": 38331, + "saved": 9989, + "pairs": 43638, + "hits": 3, + "classes": { + "F1zero": 8010, + "witness": 1713, + "F2zero": 266 + }, + "rescued": 0, + "budget_reject": { + "8": 2981, + "10": 2514, + "6": 3917, + "13": 1329, + "12": 1747, + "4": 2506, + "9": 3042, + "7": 3785, + "14": 1217, + "15": 1550, + "5": 3097, + "3": 3539, + "2": 1189, + "18": 1032, + "16": 1146, + "21": 819, + "24": 545, + "11": 1993, + "17": 1270, + "20": 871, + "19": 935, + "22": 580, + "25": 251, + "23": 793, + "28": 193, + "29": 124, + "27": 211, + "26": 240, + "30": 105, + "31": 39, + "33": 5, + "32": 10 + }, + "best_budget": { + "cut": 44827, + "frame": 246, + "cost": 0.010076421146442804, + "gain": 0.011365787087289192, + "paths": [ + { + "role": 448, + "lo": 41670, + "hi": 44828, + "frame": 246, + "old": 902, + "new": 127, + "moves": [ + 43379 + ], + "old_paid": [ + 2 + ], + "new_paid": [ + 1, + 1 + ], + "cost": 0.005038210573221402, + "private": false, + "neutral": false + }, + { + "role": 231, + "lo": 43764, + "hi": 44828, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 43989 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 472, + "lo": 31539, + "hi": 45756, + "frame": 246, + "old": 541, + "new": 127, + "moves": [ + 44555 + ], + "old_paid": [ + 2 + ], + "new_paid": [ + 1, + 1 + ], + "cost": 0.005038210573221402, + "private": false, + "neutral": false + }, + { + "role": 299, + "lo": 43732, + "hi": 45087, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 43990 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 1359, + "lo": 43757, + "hi": 47192, + "frame": 246, + "old": 246, + "new": 127, + "moves": [ + 44791 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + } + ], + "paid_roles": 2 + }, + "scope": "One total-movement-budget census on exact7115, group3,127 and existing frames; complete kernels, individual basis pair nominations plus complete decision witness; not complete cost optimization over rational combinations.", + "selected_candidate": 2, + "selected_word_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "evidence": "Discovery floating cost screens only. Public verification trusts exact source/witness/invoice instead.", + "credit": "Ali Romman, CubeJerry, Matarener and full native lineage; new screen by dillona/OpenAI Codex." +} diff --git a/research/p104-funded-cohort-split/ENVIRONMENT.json b/research/p104-funded-cohort-split/ENVIRONMENT.json new file mode 100644 index 0000000000..7503136c90 --- /dev/null +++ b/research/p104-funded-cohort-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": "Pending publication; canonical base current-CI-navigation onboarding defect is known.", + "completed_utc": "2026-11-10T18:29:09.357193+00:00" +} diff --git a/research/p104-funded-cohort-split/INPUTS.json b/research/p104-funded-cohort-split/INPUTS.json new file mode 100644 index 0000000000..69b1a847b6 --- /dev/null +++ b/research/p104-funded-cohort-split/INPUTS.json @@ -0,0 +1,111 @@ +{ + "head": "ee4a05f9c926cf85904c81b768d73acaf9e44b54", + "pr": 7116, + "prefix": "research/p104-cohort-short-caller", + "archive": "inputs/pr7116.tar", + "archive_sha256": "eff4dc88c670c15f231a60e3cddb8fc61d633d4f9ae2dc47be9597f4c5678d90", + "files": [ + { + "path": "research/p104-cohort-short-caller/APPLICATION.md", + "size": 6403, + "sha256": "d7f80bcf7e5d1362529b7054405981c607509b48d1520dfde12cbb1a3d1eb7de", + "git_blob": "8eb852df105f432e22000bce42a528a7f8ebd477" + }, + { + "path": "research/p104-cohort-short-caller/ENVIRONMENT.json", + "size": 688, + "sha256": "d7aa0c489c7e33968a503c639b90fd740dcd5f49417c544b56daa9eae31c3c4b", + "git_blob": "90e1c55795f409d3bdcfcc98a5f3e08c228dcff2" + }, + { + "path": "research/p104-cohort-short-caller/INPUTS.json", + "size": 30109, + "sha256": "ec709c038e89bc018d86a0f22fb4d1ff965f01e176f27ed4c483a68dbb7062fe", + "git_blob": "63efe1a73dfa87e7651983b4d2b10b0f6fe184cb" + }, + { + "path": "research/p104-cohort-short-caller/README.md", + "size": 7958, + "sha256": "32d4f28b1457fc51ab12230c5bbe92f303d4eeca5f1c70a78c4e490c35cbb020", + "git_blob": "7dcc21c949ff5225f52df52000eebff349b469c0" + }, + { + "path": "research/p104-cohort-short-caller/REPLAY.txt", + "size": 3699, + "sha256": "fb5a7f7a966917ff26088cfdcf17c0dda704a5b153cfc8b42a0fc7544cd53d33", + "git_blob": "682567e9ec4e7758dda0fe8abdd4cee97280e7dd" + }, + { + "path": "research/p104-cohort-short-caller/RESULT.json", + "size": 75198, + "sha256": "f49edf2c8bff58abd2b58227101f94ee01ec776522d13f6f5663a7036cd3fe7f", + "git_blob": "e22f5e7921f7a88a08785ef5c0bbee7d4858c6fe" + }, + { + "path": "research/p104-cohort-short-caller/SOURCES.json", + "size": 856, + "sha256": "8b58a30ae55396b8d108de4ee2c7c6ac75dc1096948c9ac3796c20b21b1c9372", + "git_blob": "c4150ae39789502a4adf89e8f5235995d458a72e" + }, + { + "path": "research/p104-cohort-short-caller/TASK.json", + "size": 10840, + "sha256": "d8726daf9c4d1bdfa040c1bf8a278e8cf134b5ac9062ac6003e4f838b263535f", + "git_blob": "1f381e9fd80b762c4579fe4baa39aa0040778a84" + }, + { + "path": "research/p104-cohort-short-caller/VALIDATION.md", + "size": 2262, + "sha256": "38791135c083cd813c88f632ce0304215fcf691ad1562a98717ca5574ddd6501", + "git_blob": "4b0611ca60424f03945446ce546c17179522671f" + }, + { + "path": "research/p104-cohort-short-caller/VERIFY.json", + "size": 943, + "sha256": "2072b3df23199d7e430775cb34c5e41b2b97568ab38325d7abfb6bfe66328378", + "git_blob": "203aeebebc47a460263bad15c73b8e3b5c81b86f" + }, + { + "path": "research/p104-cohort-short-caller/adapt.py", + "size": 2163, + "sha256": "68d8bbbc3ecf7f9fd1a68cebfcaa1c128648d37ee0ca52e4d939d17cbcc6782f", + "git_blob": "c8abb1e28de2ce8dc29df701f839a5705d8bdb29" + }, + { + "path": "research/p104-cohort-short-caller/inputs.py", + "size": 1940, + "sha256": "0db80e873d050e696bbdb886dbb975ac036e9bb8629541c29ac94ad8e7c82e10", + "git_blob": "a440c8e7f1d690ef0d6b5392ac16851efeebdccb" + }, + { + "path": "research/p104-cohort-short-caller/inputs/pr7113.tar", + "size": 3276800, + "sha256": "617341e053d7d4bc971ff3690ab2db01b1da8b3847ac4a71cc68f044b532efb5", + "git_blob": "58df3b969be904ed0e49d5c1d9c818215e7188a6" + }, + { + "path": "research/p104-cohort-short-caller/inputs/pr7115.tar", + "size": 2160640, + "sha256": "701fd135be7ce8fc4f7c10ba679f77cad57dd51b18a33fe491dd70fcbdd77317", + "git_blob": "4aa7b7f01a9b0d691a631ad7764329b63a352245" + }, + { + "path": "research/p104-cohort-short-caller/price.py", + "size": 3628, + "sha256": "cdb3c11c0d05927daaf9a6e54b49e4a0c6349ffd79b4d3281f2fda1387861601", + "git_blob": "81db835e3b3e5bf666e0b056134a7d2fd7036fc2" + }, + { + "path": "research/p104-cohort-short-caller/verify.py", + "size": 3346, + "sha256": "4db3120d66ac7ed52e7a3e90f52f5864a07ba6a6c43f028229e053457c0e6d48", + "git_blob": "86003afbd1c2d407a811ccaf688a56f36a5a8d87" + }, + { + "path": "research/p104-cohort-short-caller/verify_native.py", + "size": 434, + "sha256": "ede0640d2a70cc1030ae0f3bc3f3c201c62939752896db9ca3877a967d748cdb", + "git_blob": "1a36f0546148fdc2935ea29d37072ab40dd27fac" + } + ] +} diff --git a/research/p104-funded-cohort-split/NATIVE-RESULT.json b/research/p104-funded-cohort-split/NATIVE-RESULT.json new file mode 100644 index 0000000000..708e7b7cfa --- /dev/null +++ b/research/p104-funded-cohort-split/NATIVE-RESULT.json @@ -0,0 +1,3087 @@ +{ + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "new_pairs": [], + "rechecked_pairs": [ + { + "columns": 512, + "pair": [ + 3, + 127 + ], + "rank": 9 + }, + { + "columns": 512, + "pair": [ + 3, + 246 + ], + "rank": 8 + }, + { + "columns": 512, + "pair": [ + 246, + 127 + ], + "rank": 1 + }, + { + "columns": 512, + "pair": [ + 541, + 246 + ], + "rank": 1 + }, + { + "columns": 512, + "pair": [ + 902, + 246 + ], + "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_1205": true, + "missing_retiming_448": true, + "missing_retiming_472": 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": 14974998, + "fractional_bits": 24, + "mass_witness": [ + 64662, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "1630543066650225/16384", + "unscaled_maximum_mass": "7246858074001/81920" + }, + "forward": { + "coefficient_positions": 2362369, + "fractional_bits": 24, + "grid": 1125, + "rows": 1537 + }, + "gate": { + "BIT_margin": "12831820514993/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16480300000000000000000", + "alpha": [ + 0.9999999999999988, + 0.9999999999999988 + ], + "claim": "72767435897/20000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8792917302718377, + 0.8792917302718377 + ], + "derivative_upper": -407660.7473035055, + "gamma": [ + 0.9499423428823328, + 0.9499423428823328 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "363837179485007/100000000000000000": [ + "62071621929523249321921026813140712685142274543166286076902600415402176308439/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124143243859046498643842053626281425370284549086332572153805200830804352618849/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "72767435897/20000000000000": [ + "124143243859044211918464718307443275463054609592311226118102799176732249529743/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "775895274119026324490404489421520471644091309951945163238142494854576559573/625000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2232, + "moment_margin_float": { + "2273982371781852666534820721481/625000000000000000000000000000000": [ + -3.175451874744759e-29, + -3.175451874744759e-29 + ], + "363837179485007/100000000000000000": [ + 3.7078446037854665e-10, + 3.7078446037854665e-10 + ], + "7276743589701928532911426308739/2000000000000000000000000000000000": [ + 9.707895280243402e-30, + 9.707895280243402e-30 + ] + }, + "moment_margins": { + "2273982371781852666534820721481/625000000000000000000000000000000": [ + "-1587725937372379479654913483640068863597487050479161/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1587725937372379479654913483640068863597487029573417/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363837179485007/100000000000000000": [ + "9269611509463666429023179582335206383616635561151989251132005526240077/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "18539223018927332858046359164670412767233271122303978502264011073470433/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7276743589701928532911426308739/2000000000000000000000000000000000": [ + "60674345501521264697309488802685060462879361135113/6250000000000000000000000000000000000000000000000000000000000000000000000000000", + "485394764012170117578475910421480483703034910002067/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "7276743589701928532911426308739/2000000000000000000000000000000000", + "2273982371781852666534820721481/625000000000000000000000000000000" + ], + "tested": "363837179485007/100000000000000000", + "written_log_power": 2233 + }, + "grid": { + "dyadic_height": 24, + "maximum_scaled_mass": "1630543066650225/16384", + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "odd_grid_lcm": 1125, + "opcodes": { + "ADD": 63524, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6288, + "SCALE": 3678 + }, + "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": 4032, + "2": 841, + "3": 817, + "4": 237, + "5": 327, + "6": 16, + "7": 12, + "8": 6 + } + }, + "invoice": { + "P": { + "1": 72960, + "16": 416, + "2": 15138, + "24": 416, + "3": 14706, + "32": 416, + "4": 4266, + "40": 416, + "48": 416, + "5": 5886, + "56": 416, + "6": 288, + "64": 416, + "7": 216, + "8": 780, + "9": 32 + }, + "S": 1520, + "T": { + "1": 270, + "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": 1026, + "9": 11252 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036383717948509642664557131543695234137242316858585721194554740611", + "raw_crossing": "0.0036383717948509642664557131543695234137242316858585721194554740611" + }, + "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": 73599, + "helpers": { + "1": 15, + "2": 18, + "3": 46, + "4": 217, + "5": 71, + "6": 42, + "7": 18, + "8": 57, + "9": 602 + }, + "lifetimes": 54, + "owned_peak": 43, + "paid": { + "1": 4032, + "2": 841, + "3": 817, + "4": 237, + "5": 327, + "6": 16, + "7": 12, + "8": 6 + }, + "public": 1486, + "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": 851287696, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 148712304, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2781792, + "raw_upper": 833337648, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2172, + "moves": 6288, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9876000, + "scalar_upper": 1987976 + }, + "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": "4211126851894444824536521543290147243976309854597911252643013010721012012153730697069199940410189207167679992689869578977643659581353931495689860607206710815508135669852268641515482883905415782188005456146780842774480046584016353229645112132665098586805054038827509824571445470924410460958196142651789806409413/1848234575132758467382193273438208000000000000000000000", + "strict_power_of_two": 849, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "2713877739449029994976316544520294895557157216798638085639167170172208351748043425216578983501383654453990886975833937431690965235065294785360357718356746817681093902057681905955086699499854429349553516306023860493734231539565748008476127975593137390704176412172497999004142403614431861916867464194995868297454033/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": "69716180996197542779913507086853736736864102454347029531651453768184058688074481654168335897873853099609457468316995174282561197789206788619575165846078178566420553228261134771738657426654022120177780883034464423132173167844437685944767596016002061512311687797159280054789300798107692385366986771716030807597247354469/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": "2713877739449029994976316544520294895557157216798638085639167170172208351748043425216578983501383654453990886975833937431690965235065294785360357718356746817681093902057681905955086699499854429349553516306023860493734231539565748008476127975593137390704176412172497999004142403614431861916867464194995868297454033/8871525960637240643434527712503398400000000000000000000", + "strict_power_of_two": 856, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "66489921266993314983784346307467437939134565702492916235383472312836556746940524603314240102444131576482548434395558639690770337874784318990138746212322273655276222543237189200090613293257368733715866285713643474104663907545471175502231087129843720391333146952717274477189121048541054783471972614926083100418061681707012300886892949460684921795866915042464210669199296413987650252885081425398175592778375418978625340450829752424084299294951/320247285442140769134110953618454922992625780457095452694524461056000000000000000000000000000000000000000000", + "strict_power_of_two": 1104, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19548, + "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": "4211126851894444824536521543290147243976309854597911252643013010721012012153730697069199940410189207167679992689869578977643659581353931495689860607206710815508135669852268641515482883905415782188005456146780842774480046584016353229645112132665098586805054038827509824571445470924410460958196142651789806409413/1848234575132758467382193273438208000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "2713877739449029994976316544520294895557157216798638085639167170172208351748043425216578983501383654453990886975833937431690965235065294785360357718356746817681093902057681905955086699499854429349553516306023860493734231539565748008476127975593137390704176412172497999004142403614431861916867464194995868297454033/8871525960637240643434527712503398400000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "2713877739449029994976316544520294895557157216798638085639167170172208351748043425216578983501383654453990886975833937431690965235065294785360357718356746817681093902057681905955086699499854429349553516306023860493734231539565748008476127975593137390704176403300972038366901760179904149413469064194995868297454033/8871525960637240643434527712503398400000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "4211126851894444824536521543290147243976309854597911252643013010721012012153730697069199940410189207167679992689869578977643659581353931495689860607206710815508135669852268641515482883905415782188005456146780842774480046584016353229645112132665098586805054038827509824571445470924410460958196142651789806409413/1848234575132758467382193273438208000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "2713877739449029994976316544520294895557157216798638085639167170172208351748043425216578983501383654453990886975833937431690965235065294785360357718356746817681093902057681905955086699499854429349553516306023860493734231539565748008476127975593137390704176412172497999004142403614431861916867464194995868297454033/8871525960637240643434527712503398400000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "533619150369155196656908482431239693955415001345971677035579648096679708500621182539652151451215838893352204695846881139867856526343/338421858239640832650548084736000000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "1529647186875286433708473927718053483151094611832468188053786707301169451195694214096012231509719442366265767352662255801810859122881732474997/21658998927337013289635077423104000000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "19739904297295649914692852245853812274943352898438588989146951121672617881597804288213889501496940298390214150120897914186569549164864156262111114569/1082949946366850664481753871155200000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "70115442497911882521968952468533122814986857386566692340512792874065756710827309022270983471326634868163344141115412752205509759142557027242796749124065871793/7219666309112337763211692474368000000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "125833703326335874869502060733674905892364510868503422160245785777390139302200213906551160770535058050126881816628313059212826415052978949311099270382622332097635585479/5414749731834253322408769355776000000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "1908121092365153634565987810717762042772587233393595893376163512015935523927221287052393508696455105223595892661492814819686878430087310421731286020527143764058090213381193640921/34654398283739221263416123876966400000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "7875246923618516055036286642293175513175216320637776340627764497217348010144844808624352954350224846179084165557753126507066573624494383131763082060792627677097049138671343874660033817767/14439332618224675526423384948736000000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "85242515923503504493846179758294634513077491603090650005525105685476427671900738186280255383170830833965929961921147949596616610326097209562566391742611805892509655378675988930579794586555795536503/86635995709348053158540309692416000000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "2446454588545987529021285529793583676707496180637976751361691636153628109865695341104604468895459124712443757841911224494576828550607484805873079428266200056632829439345164366872582358762004340871107031513498831152088317734059481767270866279/21658998927337013289635077423104000000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "30517367335752285212854415634117480313093133883330729658795298170211860204634314365641510769943776049423677451753072391826483092253986338080046579582016446962407717784248527098644034980164184549457774912791738902898698029115938774637509784325572125881/346543982837392212634161238769664000000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "136092933463201690132869838320419113461930716108379792252163155594950194654201182917678030502180699748176073252788613055887893186412429052373845973365226652513191194066056897076728553901764517873328212487113830899348598647700063335476946593793906635877240246561/1386175931349568850536644955078656000000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "14637058514220920258784184594876668529157887779231777998895114014216760865235449278779050027610981177848105037714630783621504264810608325991228117114801620812173713432259202501167440828133669234174579094778601095011612750342566994173656557175474169851014248803681332619/154019547927729872281849439453184000000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "89814954539337936910159460201950086196776249506473577229629890342022598598199201242864155570432625040894957600332744591311816505250693472020522506439387295142829016839945482129663978407651426269141258047557896083890563796023501579273543945417532481334207188439126607209519850697/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "8863074837747741571016396578364728790728573699358524527764874908386785623680466663955737112698842971951215627952350583600898148399348018448426541248250680652046885604875872009604901283458792590128593528059204972458823940707143365776670489330036662548982151993403776552971721701508304471/1386175931349568850536644955078656000000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "4329656418352842745154645904182780466996017105163429001222424098888538799694815003274446793081045761630311069518604296006009550960434354831037088229449064885266617682014319081709485147288326117789864480824160456724803063445379282124817079038466937041551982078114113988510023380952983939456871809/11089407450796550804293159640629248000000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "8940942879763119421086251790929867648897289718310725652883469833560901610564036719221012280609649473514799659285093886372534015465060823220384390039511237195849384151228140970290541759465602302063316125815813103355564794879527047993453734285200400865436479238252022772007177183668996802510542364684191/2217881490159310160858631928125849600000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "4211126851894444824536521543290147243976309854597911252643013010721012012153730697069199940410189207167679992689869578977643659581353931495689860607206710815508135669852268641515482883905415782188005456146780842774480046584016353229645112132665098586805054038827509824571445470924410460958196142651789806409413/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": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 73599, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 256, + "witness": { + "cut": 72886, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 72886, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73599, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63524, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6288, + "SCALE": 3678 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1486, + "scalars": { + "dyadic": 61917, + "integer": 39216, + "noninteger": 27987, + "odd": 5286 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000" + }, + "M": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 14974998, + "dyadic_height": 24, + "mass_witness": [ + 64662, + "stored add" + ], + "maximum_scaled_mass": "1630543066650225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + } + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "1160253945361191331025142711618204533318202946997341765718842856686303396369911/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1160253945361191331025142711618204533318202946997341765718842856686303415026893/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.00363837179485", + "gain": "5.5966534E-8", + "gain_exact": "27983267/500000000000000", + "independent_raw_bracket": [ + "0.00363837179485096426645571315436952", + "0.00363837179485096426645571315436953" + ], + "previous_claim": "909578957079/250000000000000", + "raw_bracket": [ + "0.0036383717948509642664557131543695", + "0.0036383717948509642664557131543696" + ] + }, + "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": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8" + }, + "source_head": "e63533f866455aa5cbc6c405770c31126d76e340", + "status": "PASS_P104_FUNDED_COHORT_NATIVE", + "word_canonical_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8" +} diff --git a/research/p104-funded-cohort-split/PROOF.md b/research/p104-funded-cohort-split/PROOF.md new file mode 100644 index 0000000000..0818a53937 --- /dev/null +++ b/research/p104-funded-cohort-split/PROOF.md @@ -0,0 +1,37 @@ +# A helper split funded by two paid subdivisions + +The exact source native is #7115 at e63533f866455aa5cbc6c405770c31126d76e340, as used by #7116's current 17-stage application. The source archive authenticates the complete #7116 package and its nested #7115/#7113 exports; the replay reconstructs every #7115 native byte before applying this edit. All indices below refer to that frozen source, before insertion. + +## Legal meeting + +At cut 43729, move public roles 448,472,1205 to chart 246. Role 448's sole MOVE 43379 goes 902→127, and role 472's sole MOVE 44555 goes 541→127. Each rank 2 MOVE becomes a pair of rank 1 MOVEs through246. Role 1205's MOVE 44806 goes 902→246; advance that rank 1 MOVE without subdividing it. Their complete contact-free intervals are [41670,44828), [31539,45756), [41672,44812), respectively. The constructor checks every event and source read in each interval, actual source/destination frames, nesting, distinct roles and exact old/new rank Counters. No instruction may silently disappear from the price. + +The two new native maps compose to the original endpoint map because C_b C_f⁻¹ C_f C_a⁻¹=C_b C_a⁻¹. Their absolute phases are included in the chart replay. Moving a partial map across operations on other fields preserves the word. All three paths are public; owned labels, 54 lifetimes,peak 43 and the 23 rises of mass 56 remain unchanged after the required label shift. + +## Independent retirement and continuation + +Let P be the retimed scalar prefix and S its suffix. WITNESS.json supplies exact rational vectors a,b,c,d. The short prefix witness is + + a = e448ᵀ − e231ᵀ, c = e448ᵀ. + +The injection b uses roles1205,1062,1359,448,472,231,299,297 with coefficients5/8,5/8,−5/2,1/2,−5/8,−1/2,1/2,1/2, respectively. The full 373-coordinate d is retained explicitly. Exact replay verifies aP=c, Sb=d and ab=cd=1, with c,d supported only on independent helpers whose endpoints are3→127. Every field in a,b and pivot 231 actually occupies246. + +The attributed basis routine emits G at the input boundary and J at the cut, with row231(G)=c, Gd=e231, row231(J)=a, Jb=e231. It uses 373 and 9 scalar instructions, respectively. Both inverses are checked against the original2,3,5-smooth scalar alphabet and magnitude limit. No arbitrary rational division is granted. + +Apply G⁻¹ before P and J after P. The cut coordinate 231 equals its independent original input x231 because aPG⁻¹=cG⁻¹=e231ᵀ. Retire it at chart 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, again using the new role. Replacing the cut coordinate changes the suffix by d(z−x231), which becomes e231(z−x231) after G. The complete source acts identically on this helper group, so it commutes with G; every other native endpoint remains unchanged. This argument does not invert P or S and permits the retained owned initialization/erasure operations. + +The original pivot now has target3→246, rank 8; fresh role 1485 has target246→127, rank 1. Owned labels shift by one. Full forward and adjoint replays check every independent public input and the owned rows; the separate physical application checks the changed source rather than transferring an old success marker. + +## Complete signed change + +Write H_r=r^(1−κ). Per native invocation, + + ΔP = 4H1 − 2H2, + ΔT = H1 + H8 − H9, + Δ(T−P) = H8 + 2H2 − H9 − 3H1. + +Both rank masses are unchanged. In the unchanged 17-stage caller these deltas are multiplied by17: ΔP={1:+68,2:−34}, ΔT={1:+17,8:+17,9:−17}. The complete surplus remains1424, with no empty-root credit. Exact directed engines evaluate the entire new invoice and reject #7116's invoice at the new claim. We do not infer the result by adding published decimals or by omitting paid subdivisions. The raw crossing is the fixed-invoice ceiling; no global word/caller optimum is asserted. + +All 764 added scalar instructions, the extra independent input, the two net added MOVE occurrences, both odd conversion services, current precision and actual physical routes enter the source-specific application in APPLICATION.md. 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 discovery kernel/decision method; Rohan Arun for the 17-stage caller; ToikY, DreamingOfClouds and the complete source lineage. This concrete paid cohort and its verification were prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-funded-cohort-split/README.md b/research/p104-funded-cohort-split/README.md new file mode 100644 index 0000000000..91c1db6541 --- /dev/null +++ b/research/p104-funded-cohort-split/README.md @@ -0,0 +1,54 @@ +# Conditional κ .003638942433483 from a fully charged helper meeting + +The candidate improves [#7116](https://github.com/CrocSwap/integer-mult-bounds/pull/7116) by **.000000056433774**, using a new native word with the same signed 17-stage caller. Two paid rank 2 moves become four paid rank 1 moves; together with one neutral retiming, they permit one independent helper 9 target to become helper 8+helper 1. The complete signed profile changes. This is not a refinement of the old numerical root. The selected frontier is unchanged. + +The conditional claim is `3638942433483/1000000000000000`. The independent raw crossing is + +``` +(.00363894243348326426360596453075559, + .00363894243348326426360596453075560). +``` + +That bracket is the fixed-invoice ceiling. The retained BIT cap .00376669 leaves .000127747566517 parameter headroom; this is not a claim that it is attainable. Both source-aware exact price engines reject #7116's invoice at the new claim. `VALIDATION.md` distinguishes completed runs from remaining verification. + +## Concrete change + +[PROOF.md](PROOF.md) gives the exact construction. At source #7115 cut 43729, roles 448 and 472 split their rank 2 MOVEs through chart 246; role 1205 neutrally advances its rank 1 MOVE. Pivot 231 retires there and fresh role 1485 starts with an independent arbitrary input. `WITNESS.json` contains the entire rational cut and boundary vectors. The constructor checks all contacts, reads, frames, path Counters and declared paid changes. + +The new native has 73,599 events, 1,486 public inputs, 1,086 independent helpers and 51 owned labels. It adds 762 ADD, 2 SCALE and 2 net MOVE occurrences. All 54 owned lifetimes, peak 43 and 23 rises of mass 56 are unchanged. Native odd scale 1125 and fractional height 24 are derived afresh from every prefix coefficient and pre-ADD product. The complete ordinary bound is **777,561,336 < 10⁹**; fresh precision gives **c=2336**, replacing #7116's 2328. + +| Complete 17-stage invoice | #7116 | This construction | +|---|---:|---:| +| Paid positions |110638|110672| +| Productive fields |22189|22206| +| Rank surplus |1424|1424| +| Empty-root credits |0|0| + +The exact changes are ΔP={1:+68,2:−34} and ΔT={1:+17,8:+17,9:−17}. Every subdivision and all scalar/ordinary/precision work are charged. The new input remains arbitrary; it is not zero scratch. + +## Sources and reproduction + +The complete input is [#7116](https://github.com/CrocSwap/integer-mult-bounds/pull/7116) at `ee4a05f9c926cf85904c81b768d73acaf9e44b54`. Its nested exports retain [#7115](https://github.com/CrocSwap/integer-mult-bounds/pull/7115) native source at `e63533f866455aa5cbc6c405770c31126d76e340` and **Rohan Arun's [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113)** caller at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. The 17 outer files and both nested complete inventories are authenticated before import. `INPUTS.json` pins SHA256 and Git blobs; original archives and notices are unchanged. + +The source native canonical hash is `ae30929ff3b5f6b49a5edac78e2164acfbf809113d0b9f03249ef940dd7b2491`; the emitted candidate is `954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8`. The literal caller retains hash `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-funded-cohort-split +``` + +The first command reconstructs the source and candidate, checks both native orientations and the exact invoice, derives the grid, and runs the complete finite physical native and signed-child checks. It also prices the unchanged 18-stage ingredient caller; that receipt is not substituted for the final 17-stage application. The second command reconstructs the current and new 17-stage invoices, emits and checks the entire literal caller, invalidates same-native caches, and freshly runs every affected component. All 3,047 paid/helper chart maps and 104 main boundary pairs receive signed-Pauli and absolute-phase checks. Five affected chart pairs additionally receive all 512 column checks in the native command. + +Sixteen native corruption controls reject missing paths/corrections, wrong vectors/frames, unpaid subdivisions, changed path ranks, illegal contacts and inadequate grids. Phase, owner-alias, caller-grid and BIT controls remain active. Every resulting receipt field is compared. The standard-library replay requires neither Git nor network; optimized Python is rejected. `--out UNUSED_PATH` writes a new receipt without overwriting a frozen one. + +## Scope, obligations and credit + +`APPLICATION.md` supplies the changed-source 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, selected-frontier change or global optimum is claimed. + +Prepared for dillona with substantial OpenAI Codex assistance; no subagents. Apache-2.0. Credit **Ali Romman** for independent-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 its component application; **DreamingOfClouds** and **ToikY** for the native/signed caller lineage; **Douglas Colkitt and the #7000 reviewers** for the selected source-specific application, including BIT ambient 134; and all retained predecessor authors/notices. The preceding #7105/#7107/#7112/#7115/#7116 contributions remain credited. + +## Open next questions + +- Independently review this paid cohort and complete component application using the exact source closure and registered commands. +- A larger improvement needs a changed complete profile or interface. Refresh current priorities and live handoffs, and establish its full budget before extending a closed search. This fixed-invoice bracket is not a universal limit. + +The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521) records scope changes, overlap and the local negative rounds. They are not presented as global barriers or additional κ results. diff --git a/research/p104-funded-cohort-split/REPLAY.txt b/research/p104-funded-cohort-split/REPLAY.txt new file mode 100644 index 0000000000..068a55d94c --- /dev/null +++ b/research/p104-funded-cohort-split/REPLAY.txt @@ -0,0 +1,77 @@ +Actual registered CPython3.12.16 stdout. Command: +/tmp/kappa-python312/python/bin/python3.12 -B scripts/research_package.py --package research/p104-funded-cohort-split +The task metadata was partial while checks ran; it was marked completed only after this successful exit. No scientific file or receipt changed after this comparison. + +CHECK Authenticate/reconstruct exact7115 from complete7116 closure, verify funded paths and both arbitrary-input native orientations, paid/target Counters, grids,18-stage ingredient bill, precision, all512columns of5affectedmaps,16negativecontrols and full finite physical replay; compare 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 73599 public 1486 owned roles 51 paid {1: 4032, 2: 841, 3: 817, 4: 237, 5: 327, 6: 16, 7: 12, 8: 6} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 15, 2: 18, 3: 46, 4: 217, 5: 71, 6: 42, 7: 18, 8: 57, 9: 602} +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 73599 events, 2962 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1086), 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_COHORT_NATIVE 72767435897/20000000000000 +CHECK Reconstruct current7116 and candidate17-stage invoices, literal caller, all3047paid/helpermaps and104mainboundaries, grids/envelopes, ordinary/physical/fixed-tape costs, two exact prices and all54+4outer checks; compare every RESULT field. +PASS two reconstructed invoices and both exact price engines 0.003638942433483 +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 ['7277884866966528527211929061511/2000000000000000000000000000000000', '9097356083708160659014911326889/2500000000000000000000000000000000'] +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 110672 13600 22206 +RUN check_odd_precision.py +PASS short precision 405 1168 2336 +RUN check_odd_partial_admission.py +ordinary bill 777561336 +PASS partial signed short gates 777561336 3638942433483/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 42244960 25460171456 precision 2336 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3047 +PASS complete 8+9 component application checks 3638942433483/1000000000000000 3047 110672 +PASS_P104_FUNDED_COHORT_SPLIT 3638942433483/1000000000000000 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-funded-cohort-split outcome=partial diff --git a/research/p104-funded-cohort-split/RESULT.json b/research/p104-funded-cohort-split/RESULT.json new file mode 100644 index 0000000000..7d2efa1e28 --- /dev/null +++ b/research/p104-funded-cohort-split/RESULT.json @@ -0,0 +1,1545 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "378f2b45f8cb8bd37737cf9a4a89e56d8c451f67e6d842f015ff977c2af1c20e", + "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(\".003638942433483\")", + "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": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "92901236d487141c27de335c231ca14363924c6c3e2f7667fc9ef08d59948e1b", + "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": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + }, + { + "catalogue_digest": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "511f4c30588d834eb50797256e8222a929934017b5be1f8312ee980a2a99bc37", + "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": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + }, + { + "catalogue_digest": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1047, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "adb3267d45e631d7dd8e8a5ab6fce7e6be2c49889e4441a248b90bdcce54dce0", + "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": 3047, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "3638942433483/1000000000000000", + "catalogue": [ + { + "catalogue_digest": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "92901236d487141c27de335c231ca14363924c6c3e2f7667fc9ef08d59948e1b", + "log_sha256": "022cb745b61a69184d1c08d75be4a2d5ae857563a460884d64d5b5506e483016", + "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": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + }, + { + "catalogue_digest": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1000, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "511f4c30588d834eb50797256e8222a929934017b5be1f8312ee980a2a99bc37", + "log_sha256": "ebc51164d05bb2b1e25b731f173ca85dc1aecb2ce1083d5c7acf4852f199abb9", + "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": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + }, + { + "catalogue_digest": "e1d841321a0cea8d093a84981d095795464e547c500bca159601c0cc669284ce", + "catalogue_size": 3047, + "checked_maps": 1047, + "distinct_helper_maps": 184, + "distinct_paid_maps": 2962, + "exact_recipe_digest": "adb3267d45e631d7dd8e8a5ab6fce7e6be2c49889e4441a248b90bdcce54dce0", + "log_sha256": "40a3702c5a532c2309221bdae6f3441081a0964134356c7bd22ef5f7a0423bb1", + "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": 3047, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56" + } + ], + "fixed_tape_counts": { + "H": 16480300000000000000000, + "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": 2336, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25460171456, + "log_power": 2233, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298604, + "native_invocations": 17, + "native_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58012, + "native": 1144287 + }, + "scalar_services_upper": 42244960, + "scalar_steps_coefficient": 44297051176960, + "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": "3638942433483/1000000000000000" + }, + "native_archive_sha256": "57041df5c0d953d9e07b991006b8f8e7995f785cca293b5cad3ee172cad87d56", + "native_canonical_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "numeric_gate": { + "BIT_margin": "12774756651693/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16480300000000000000000", + "alpha": [ + 0.9999999999999998, + 0.9999999999999998 + ], + "claim": "3638942433483/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8992843070580269, + 0.8992843070580269 + ], + "derivative_upper": -382346.6350758539, + "gamma": [ + 0.9407686724727129, + 0.9407686724727129 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3638942433483/1000000000000000": [ + "24832377014040220309202953038377629610893200911295689724032292847749730104917/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535100550773007382595944074027233002278239224310080732119374325263263/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363894243348307/100000000000000000": [ + "62080942535101694119814925055596940578355401593568852863661963023384415119517/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535101694119814925055596940578355401593568852863661963023384415120501/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2232, + "moment_margin_float": { + "363894243348307/100000000000000000": [ + 7.545315791215119e-11, + 7.545315791215119e-11 + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + 3.7341413412008116e-29, + 3.7341413412008116e-29 + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + -1.4991905897150026e-30, + -1.4991905897150026e-30 + ] + }, + "moment_margins": { + "363894243348307/100000000000000000": [ + "3772657895607559738224246769393294923102708746577201343086225879056719/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1886328947803779869112123384696647461551354373288600671543112949267923/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + "3734141341200811665323867855800973224640717883376873/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "149365653648032466612954714232038928985628716883477/4000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + "-149919058971500251497146676633127233728956800080389/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-74959529485750125748573338316563616864478380659751/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "7277884866966528527211929061511/2000000000000000000000000000000000", + "9097356083708160659014911326889/2500000000000000000000000000000000" + ], + "tested": "363894243348307/100000000000000000", + "written_log_power": 2233 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "d504c37540960ec32105873da8dd6bfa17ec58386dda111753ac2e81b4bed241", + "fresh_helpers": 18462, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1486, + "nonzero_boundary_translations": 13600, + "paid": { + "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 + }, + "paid_positions": 110672, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22206, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "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 + } + }, + "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": 777561336, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222438664, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2627248, + "raw_upper": 760925928, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2172, + "moves": 6288, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9876000, + "scalar_upper": 1987976 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12774756651693/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16480300000000000000000", + "alpha": [ + 0.9999999999999998, + 0.9999999999999998 + ], + "claim": "3638942433483/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8992843070580269, + 0.8992843070580269 + ], + "derivative_upper": -382346.6350758539, + "gamma": [ + 0.9407686724727129, + 0.9407686724727129 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3638942433483/1000000000000000": [ + "24832377014040220309202953038377629610893200911295689724032292847749730104917/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535100550773007382595944074027233002278239224310080732119374325263263/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363894243348307/100000000000000000": [ + "62080942535101694119814925055596940578355401593568852863661963023384415119517/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535101694119814925055596940578355401593568852863661963023384415120501/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2232, + "moment_margin_float": { + "363894243348307/100000000000000000": [ + 7.545315791215119e-11, + 7.545315791215119e-11 + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + 3.7341413412008116e-29, + 3.7341413412008116e-29 + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + -1.4991905897150026e-30, + -1.4991905897150026e-30 + ] + }, + "moment_margins": { + "363894243348307/100000000000000000": [ + "3772657895607559738224246769393294923102708746577201343086225879056719/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1886328947803779869112123384696647461551354373288600671543112949267923/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + "3734141341200811665323867855800973224640717883376873/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "149365653648032466612954714232038928985628716883477/4000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + "-149919058971500251497146676633127233728956800080389/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-74959529485750125748573338316563616864478380659751/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "7277884866966528527211929061511/2000000000000000000000000000000000", + "9097356083708160659014911326889/2500000000000000000000000000000000" + ], + "tested": "363894243348307/100000000000000000", + "written_log_power": 2233 + }, + "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": 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" + }, + "native_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "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": 777561336, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222438664, + "odd_divisions": { + "ADD": 5219, + "SCALE": 67 + }, + "per_input_conversion": 2627248, + "raw_upper": 760925928, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2172, + "moves": 6288, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9876000, + "scalar_upper": 1987976 + }, + "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": 16480300000000000000000, + "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": 2336, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25460171456, + "log_power": 2233, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298604, + "native_invocations": 17, + "native_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58012, + "native": 1144287 + }, + "scalar_services_upper": 42244960, + "scalar_steps_coefficient": 44297051176960, + "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": "3638942433483/1000000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "d504c37540960ec32105873da8dd6bfa17ec58386dda111753ac2e81b4bed241", + "fresh_helpers": 18462, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1486, + "nonzero_boundary_translations": 13600, + "paid": { + "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 + }, + "paid_positions": 110672, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22206, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "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 + } + }, + "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": 2336, + "context_height": 405, + "context_mass_bits": 1168, + "native_grid": { + "coefficient_visits": 14974998, + "dyadic_height": 24, + "mass_witness": [ + 64662, + "stored add" + ], + "maximum_scaled_mass": "1630543066650225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "precision_program_sha256": "7696f2e4074ccc9c970670494595e2a973742279a6109d1e60fd551a4611d236", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "545291629389773761950122747858148802844031872836052291357592006653777736249117111802708780043663611238119399382846250110806551139950973621724546682530943487213559838817034335614651029139810912341599770649653436148610503197167802882219124053403840296630098160732588551411714469379519258582306354753028070885964843639699312628512736319235920428149438571863357517975974388024438239621697854618482511085552865352452908806861/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1131, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "14072669418125677990760120363905743974023893871758851539287946395089390829724924233881945273113246525178805074355287268248344403683097586784142859297291453587931319664204946478850399660760080617744973936099584519577304103654628158120335085875844760230827363558628750548887946863548522031708956534406316713268452334867008229604940680835253914566936526937545049093544407180465579834895748749571878007667090894404791731557231/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": "196519305436150507387849650061925345043630470367856838148987603470176268548187165181066575845896773111709298796199359307991788282617469907653429553409681991227154669680231000204715725173649792633753803515822338856680389089272516840094416838406476911978767797821487113868441627409182392027048603552994434031302490018748465766026254644903530015155124879146638021164441223464820822154231441135962438050686582367275468091232861317/105381592244960720944124955879014400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1147, + "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": "14072669418125677990760120363905743974023893871758851539287946395089390829724924233881945273113246525178805074355287268248344403683097586784142859297291453587931319664204946478850399660760080617744973936099584519577304103654628158120335085875844760230827363558628750548887946863548522031708956534406316713268452334867008229604940680835253914566936526937545049093544407180465579834895748749571878007667090894404791731557231/14819286409447601382767571920486400000000000000000000000000000000000000000000000", + "strict_power_of_two": 1137, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "8609666433906168698509279080481641526966394613910658491284272324660615461097037243419019995686388420938441482940511384346049354717577278128952394309867713958556280700146357863021589010670332405177208685464831688211654373297608472645286623143486554475123012846089079738948045506796147092543253734485418425690806526142607836393142778732512224687356789879601165370049162621033953507262609685331569611950438839591537233311351654677881425937339378296279579876727224549114232636885472499551747905591255984922268220637922137561219031740408983435400201222847/3423689690092006159733108133936318139518312371955275640514963046400000000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1387, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18462, + "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": "545291629389773761950122747858148802844031872836052291357592006653777736249117111802708780043663611238119399382846250110806551139950973621724546682530943487213559838817034335614651029139810912341599770649653436148610503197167802882219124053403840296630098160732588551411714469379519258582306354753028070885964843639699312628512736319235920428149438571863357517975974388024438239621697854618482511085552865352452908806861/19759048545930135177023429227315200000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "14072669418125677990760120363905743974023893871758851539287946395089390829724924233881945273113246525178805074355287268248344403683097586784142859297291453587931319664204946478850399660760080617744973936099584519577304103654628158120335085875844760230827363558628750548887946863548522031708956534406316713268452334867008229604940680835253914566936526937545049093544407180465579834895748749571878007667090894404791731557231/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "14072669418125677990760120363905743974023893871758851539287946395089390829724924233881945273113246525178805074355287268248344403683097586784142859297291453587931319664204946478850399660760080617744973936099584519577304103654628158120335085875844760230827363558628750548887946863548522031708956534406316713268452334867008229604940680835253914552117240528097447710776835259979179834895748749571878007667090894404791731557231/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "545291629389773761950122747858148802844031872836052291357592006653777736249117111802708780043663611238119399382846250110806551139950973621724546682530943487213559838817034335614651029139810912341599770649653436148610503197167802882219124053403840296630098160732588551411714469379519258582306354753028070885964843639699312628512736319235920428149438571863357517975974388024438239621697854618482511085552865352452908806861/19759048545930135177023429227315200000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "14072669418125677990760120363905743974023893871758851539287946395089390829724924233881945273113246525178805074355287268248344403683097586784142859297291453587931319664204946478850399660760080617744973936099584519577304103654628158120335085875844760230827363558628750548887946863548522031708956534406316713268452334867008229604940680835253914566936526937545049093544407180465579834895748749571878007667090894404791731557231/14819286409447601382767571920486400000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "6485988378721198095610726269366231300628328157625817407859170397733885868917777011560755760151929079595852320476263803384779390497371/423027322799551040813185105920000000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "9854759050337099382272636410984471093654481486391963033211563820938877114193355752792378424832995398947554627012071184644402388760105935495752411/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "9178767388058014622214042841805471813372666932726962736827970186106937995503797054687582762251372210295295279672547911885067282944212813912550654929517723/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "1875014891777640999616506398641713947337570671727649243382924577750138192264206595059524454746611526228855180606787269305805945277819141817733477694036738073051459133/40610622988756899918065770168320000000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "179532646915584185501695954467081150109458271306287936370882625612861480208495817415010105961904455603791630100310786752449320347195794309874360511555776088155324406770283793497/609159344831353498770986552524800000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "19148073303118082341576199090334998043196932103210664954258777025650087725899345479971869069793071510084346104003701522619310624947914669211596655130494566738655876145752117455632236093047/67684371647928166530109616947200000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "5575141324575148004942357675619647991603053416414768280258770803836339012289108210669041570402689722015953705472774860783050643804510530114367295744176248536651708636518856012358052139410980431243438236113/76144918103919187346373319065600000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "1988222274355457067208727363229969004725292108698702952699804636156049451165331722027675857445978282400379655849477862113628602653437500219252402014057818829339758814554913111619810093950105042769609321317167641107865240038657119573640060349339450943354644583610812260568492387180615451033735610861395785293599310701260250017633440907281173/87817993537467267453437463232512000000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "756024281537279397809481385677770668767068091262568035772119127777160784242091287105413249514955728946759097867455045641824746198362006990497532548586011742243109113280603100640600427204952127066123947809612908211566563791570962262028455618723561176835349707264444894005684927578929934524368228074804556579558456428646711766754307533402068320063273971767/2195449838436681686335936580812800000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "360688452683964910120351521549988496116476917629363243111006363835968976260820194849170908550275883096356210737463393745013950076281464635326949314171556205400861326817570387827850577993741496219742721874107493976008993412893866339253938160051006830458710647290775711860814281057558946033213030290540612743667127676880691717003926073490845017961530402531041769712973/73181661281222722877864552693760000000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "4532560077205223125316580456830645042338370875927193447394673792449366122130046915851945504307136128410755139847568944071328700931742893385486468602981839599619578112555952879615194284840133610824533017885985380205098218993798650803683842025715218273696097896000942185788330486701284892314333897824001214572746349036328072327688408822195323765646604896756773942772333705923133421/9879524272965067588511714613657600000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "298556848231317777436158569245084182629510955193082726433183386290159202711694286382223473740798498255444137116325562820083771213897484749216566081896036575591413958809660678171351463129643814923458933204184320209614331314715139835487545758186974810950078511533266049730710902923244346038238673714789314840917385737221885984474309326427767829384906065615273703996386926153008729666661549/2469881068241266897127928653414400000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "11990512786444419458364058393118641436787940343914132812793785390257855581584313269253458458803887096816157094337617467073280392873696322567187239786924109145791482811637264835494634150849818287611836865857393294635775678442489517572191612161765473811199468311805225146543495753109302321223570072176956328260562408184404366435790530197420321213344242649026058897994842696944554002830503785461161781/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "229164641482011643040878199928640944563860929022222776286584617115953987298509533352643374382086568474175397894541549959141846071911778481788587730689898076074412920559705189452035177147587651735604087462595573388966115500818863787777626860271376252541607648349907945790157445975551268168903576115354151024202181507768516657160122668216893621661111474040199559715767830101530916330307811417393534691792551/9879524272965067588511714613657600000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "253683066441815944975028718496930581600129819077112048426359661573176615448372550612337842735152149405641828147633537347031994817353574179637150771131948465312086617883189130338715098257024574830298828410957938418701907763846958221727485261109559666314836392752567602512646476912313004811427955718768143631792284859223448776404986065278198875109245102991176989271798724422836897144674099943545386436394676536440733/19759048545930135177023429227315200000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "545291629389773761950122747858148802844031872836052291357592006653777736249117111802708780043663611238119399382846250110806551139950973621724546682530943487213559838817034335614651029139810912341599770649653436148610503197167802882219124053403840296630098160732588551411714469379519258582306354753028070885964843639699312628512736319235920428149438571863357517975974388024438239621697854618482511085552865352452908806861/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": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 73599, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 256, + "witness": { + "cut": 72886, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000", + "strict_power_of_two": 251, + "witness": { + "cut": 72886, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73599, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63524, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6288, + "SCALE": 3678 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1486, + "scalars": { + "dyadic": 61917, + "integer": 39216, + "noninteger": 27987, + "odd": 5286 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000" + }, + "M": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/1353687432958563330602192338944000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26054, + "entrance_mass": "15789104343195391508273070096329586700532069492091744026779512820250179798131634764069563967436760003643239935568249101692952861627/173271991418696106317080619384832000000000000000000000", + "residual_mass": "3781020118678073539172176789162123799557963887069259603032499224810138857575771738412665349809071510644398759335984873201974453/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": 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 + }, + "raw_bracket": [ + "7277884866966528527211929061511/2000000000000000000000000000000000", + "9097356083708160659014911326889/2500000000000000000000000000000000" + ], + "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": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "target": { + "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 + } + } + }, + "claim": "3638942433483/1000000000000000", + "price": { + "after": { + "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" + }, + "before": { + "P": { + "1": 68860, + "16": 416, + "2": 14331, + "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": 238, + "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": 952, + "9": 10667 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036388859997098507738846037035137456073258794909424591024447765685", + "raw_crossing": "0.0036388859997098507738846037035137456073258794909424591024447765685" + }, + "gate": { + "BIT_margin": "12774756651693/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16480300000000000000000", + "alpha": [ + 0.9999999999999998, + 0.9999999999999998 + ], + "claim": "3638942433483/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8992843070580269, + 0.8992843070580269 + ], + "derivative_upper": -382346.6350758539, + "gamma": [ + 0.9407686724727129, + 0.9407686724727129 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3638942433483/1000000000000000": [ + "24832377014040220309202953038377629610893200911295689724032292847749730104917/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535100550773007382595944074027233002278239224310080732119374325263263/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "363894243348307/100000000000000000": [ + "62080942535101694119814925055596940578355401593568852863661963023384415119517/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62080942535101694119814925055596940578355401593568852863661963023384415120501/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2232, + "moment_margin_float": { + "363894243348307/100000000000000000": [ + 7.545315791215119e-11, + 7.545315791215119e-11 + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + 3.7341413412008116e-29, + 3.7341413412008116e-29 + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + -1.4991905897150026e-30, + -1.4991905897150026e-30 + ] + }, + "moment_margins": { + "363894243348307/100000000000000000": [ + "3772657895607559738224246769393294923102708746577201343086225879056719/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1886328947803779869112123384696647461551354373288600671543112949267923/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7277884866966528527211929061511/2000000000000000000000000000000000": [ + "3734141341200811665323867855800973224640717883376873/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "149365653648032466612954714232038928985628716883477/4000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9097356083708160659014911326889/2500000000000000000000000000000000": [ + "-149919058971500251497146676633127233728956800080389/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-74959529485750125748573338316563616864478380659751/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "7277884866966528527211929061511/2000000000000000000000000000000000", + "9097356083708160659014911326889/2500000000000000000000000000000000" + ], + "tested": "363894243348307/100000000000000000", + "written_log_power": 2233 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "954d64194222d5080cfc7ca860e78a59979c825e0c68632f5e4ce75ae496bab8", + "old_native": "ae30929ff3b5f6b49a5edac78e2164acfbf809113d0b9f03249ef940dd7b2491", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "2191922099441697453845402069797877544499844355504986538245021593393332709677587/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2191922099441697453845402069797877544499844355504986538245021593393332743991157/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003638942433483", + "gain": "5.6433774E-8", + "gain_exact": "28216887/500000000000000", + "independent_raw_bracket": [ + "0.00363894243348326426360596453075559", + "0.0036389424334832642636059645307556" + ], + "previous_claim": "3638885999709/1000000000000000", + "raw_bracket": [ + "0.0036389424334832642636059645307555", + "0.0036389424334832642636059645307556" + ] + } + }, + "status": "PASS_P104_FUNDED_COHORT_SPLIT" +} diff --git a/research/p104-funded-cohort-split/SOURCES.json b/research/p104-funded-cohort-split/SOURCES.json new file mode 100644 index 0000000000..c4150ae397 --- /dev/null +++ b/research/p104-funded-cohort-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-cohort-split/TASK.json b/research/p104-funded-cohort-split/TASK.json new file mode 100644 index 0000000000..a780658f5b --- /dev/null +++ b/research/p104-funded-cohort-split/TASK.json @@ -0,0 +1,159 @@ +{ + "task_id": "p104-side-correction", + "scope_status": "changed", + "scope_change_reason": "The neutral and one-paid-role subspaces were closed locally. Changed to a total signed-cost constraint: several cheap subdivisions may jointly expose a profitable independent helper mode. An exact interval preflight showed headroom; the concrete whole invoice is recomputed.", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "concrete_question": "Can a fully charged joint meeting improve the complete current7116 invoice?", + "domain": "Sourcecut43729/chart246/pivot231; paths448,1205,472;762ADD+2SCALE+2netMOVEs.", + "success": "Entire source reconstruction, both arbitrary-input native orientations, full signed caller and phase catalogue, both exact prices, current ordinary/grid/envelope/compiler/outer and fixed-tape application.", + "stop": "One new verified profile; no automatic expansion of frame or role-count searches.", + "predecessors": [ + "Ali Romman #5599 helper split and dyadic basis methods", + "Jerry Chen / CubeJerry #6805/#6916 paid retiming", + "DreamingOfClouds #6931 word and caller", + "retained source lineage in #6931 NOTICE", + "DreamingOfClouds #6936/#6937; CubeJerry #7000/#7001; ToikY #7003/#7004", + "dillona with OpenAI Codex #7105 causal paid retiming and split; public head92b09a2", + "dillona / OpenAI Codex #7107 exact rank-eight split and full source-bound verification", + "ToikY #7108/#7109 signed caller and source; #7110 prior publication of same gain", + "ToikY #7110 exact public source and prior chart117 split", + "dillona / OpenAI Codex #7112 smooth-swap source and verification", + "Rohan Arun #7113 concurrent17-stage caller, acknowledged but not imported", + "Rohan Arun7113 signed17-stage caller; exact07a76c5e2738882c0cb322278e56f6cae3c9885d", + "dillona/OpenAI Codex7115 native and7116 complete composition", + "Ali Romman paid-meeting splits5751", + "Matarener complete helper-kernel and pairing decision" + ], + "evidence_status": "Complete CPython3.14.7 native and composition runs passed. Final isolated registeredCPython3.12.16 replay passed both complete commands and matched every frozen receipt field, with all16nativecontrols and full physical/application checks.", + "overlap": "Canonicalmain e545/priorityrevision8 unchanged. Refreshed cache covers416openPRs at18:22:21UTC and7021Discussionrecords at18:23:29UTC, completepagination. ToikY7111 updated17:40 reports a distinct rank8 helper/chart120 lead, with one paid rank7-to-4+3 move; that pending lead is not claimed here. Current contribution is chart246 rank9 helper with two rank2 subdivisions. No new stronger public bound appeared in livePRcheck.", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "predecessor_head": "ee4a05f9c926cf85904c81b768d73acaf9e44b54", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521", + "schema_version": 1, + "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" + } + ] + }, + "actual_scope": "A fully charged three-role meeting on exact7115, with two rank2 paid subdivisions and one neutral rank1 retiming, then one H9-to-H8+H1 split; retain and freshly recheck the7116 signed17 caller.", + "bottleneck_link": "The cut basis needs all three moved roles simultaneously; removing any one rejects. Per-role exact paid Counter equality pays the complete movement boundary.", + "stop_rule": "One verified new complete claim; preserve this package and refresh before any further research round.", + "evidence": "WITNESS.json, WORD.json.gz, RESULT.json, REPLAY.txt, SEARCH.txt, and exact19-file predecessor closure inputs/pr7112.tar.", + "author": "Prepared for dillona with substantial OpenAI Codex assistance", + "outcome": "completed", + "open_questions": [ + { + "question": "Can an independent reviewer verify the complete source-specific application and each paid subdivision?", + "why_it_matters": "A favourable local target change alone does not establish the complete conditional claim.", + "first_step": "Replay the registered3.12 commands, then examine PROOF.md and APPLICATION.md against the exact source manifest.", + "blocked_by": "Independent human/formal review and maintainer admission remain separate." + }, + { + "question": "Can a different physical word or interface beat this fixed-invoice crossing?", + "why_it_matters": "The bracket prices only the emitted program.", + "first_step": "Refresh canonicalmain and live handoffs; name a changed contract and complete optimistic budget before another construction round.", + "blocked_by": "No global word/caller optimum or further candidate is established here." + } + ], + "checkpoints": [ + { + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "decision": "Canonical main unchanged through verification; scope changed to exact histogram-neutral cohort. Source7112 frozen; parallel7113 caller read and credited." + }, + { + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "decision": "Final canonical fetch unchanged. Live7113 head07a76c5e2738882c0cb322278e56f6cae3c9885d and7114 headfc90dc68b54d613a0600e5bddd8e4f557a4b4eda read; this claim exceeds7113." + } + ] +} diff --git a/research/p104-funded-cohort-split/VALIDATION.md b/research/p104-funded-cohort-split/VALIDATION.md new file mode 100644 index 0000000000..967bf87c01 --- /dev/null +++ b/research/p104-funded-cohort-split/VALIDATION.md @@ -0,0 +1,16 @@ +# Validation record + +CPython 3.14.7 on macOS arm64 completed both direct commands from a cold authenticated source reconstruction: + +``` +python3 -I -B research/p104-funded-cohort-split/verify_native.py --out research/p104-funded-cohort-split/NATIVE-RESULT.json +python3 -I -B research/p104-funded-cohort-split/verify.py --out research/p104-funded-cohort-split/RESULT.json +``` + +The native command passed source reconstruction, exact paid/target changes, forward and adjoint endpoints, native grid derivation, both ingredient price engines, precision, 16 rejection controls, five 512-column chart checks including absolute phase, complete finite native execution and signed routes. The composition command passed both full 17-stage invoices and price engines, the unchanged literal caller, rational and integer Laurent endpoints, owner/phase occurrence binding, fresh grids/envelopes, complete ordinary and fixed-tape costs, all 3,047 paid/helper chart maps and 104 main boundaries, and 54 strict + 4 functional outer conditions. + +The final registered isolated CPython 3.12.16 replay passed both complete commands and matched every field in both frozen receipts. REPLAY.txt preserves its actual output; the process exited successfully. Metadata was marked completed afterwards. ENVIRONMENT.json records the interpreter source and archive digest. No Lean, Docker or concurrent artifact-regenerating suites are used. + +The earlier candidate exploration compared three words with the same paid/target profile; only source cut 43729 is submitted. No search optimum, independent human review, formal-kernel verification or compiled top-level multiplier is claimed. Independent review and maintainer admission remain separate; the five assumptions remain. + +Hosted CI is not claimed to pass. Canonical main currently has a CI-navigation test expecting selected #7000 while its guide names #6030. The existing correction handoff is linked in the PR; hosted status will be reported separately from local scientific replay. diff --git a/research/p104-funded-cohort-split/VERIFY.json b/research/p104-funded-cohort-split/VERIFY.json new file mode 100644 index 0000000000..51e4ea1272 --- /dev/null +++ b/research/p104-funded-cohort-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 exact7115 from complete7116 closure, verify funded paths and both arbitrary-input native orientations, paid/target Counters, grids,18-stage ingredient bill, precision, all512columns of5affectedmaps,16negativecontrols and full finite physical replay; compare every NATIVE-RESULT field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Reconstruct current7116 and candidate17-stage invoices, literal caller, all3047paid/helpermaps and104mainboundaries, grids/envelopes, ordinary/physical/fixed-tape costs, two exact prices and all54+4outer checks; compare every RESULT field." + } + ] +} diff --git a/research/p104-funded-cohort-split/WITNESS.json b/research/p104-funded-cohort-split/WITNESS.json new file mode 100644 index 0000000000..f1bb5022e8 --- /dev/null +++ b/research/p104-funded-cohort-split/WITNESS.json @@ -0,0 +1,471 @@ +{ + "frame": 246, + "pivot": 231, + "cut": 43729, + "ranks": [ + 8, + 1 + ], + "gain": 0.0012893659408463876, + "paths": [ + { + "role": 448, + "lo": 41670, + "hi": 44828, + "frame": 246, + "old": 902, + "new": 127, + "moves": [ + 43379 + ], + "old_paid": [ + 2 + ], + "new_paid": [ + 1, + 1 + ], + "cost": 0.005038210573221402, + "private": false, + "neutral": false + }, + { + "role": 1205, + "lo": 41672, + "hi": 44812, + "frame": 246, + "old": 902, + "new": 246, + "moves": [ + 44806 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 1, + 0 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 472, + "lo": 31539, + "hi": 45756, + "frame": 246, + "old": 541, + "new": 127, + "moves": [ + 44555 + ], + "old_paid": [ + 2 + ], + "new_paid": [ + 1, + 1 + ], + "cost": 0.005038210573221402, + "private": false, + "neutral": false + } + ], + "a": { + "448": "1", + "231": "-1" + }, + "b": { + "1205": "5/8", + "1062": "5/8", + "1359": "-5/2", + "448": "1/2", + "472": "-5/8", + "231": "-1/2", + "299": "1/2", + "297": "1/2" + }, + "c": { + "448": "1" + }, + "d": { + "1062": "-15041/1024", + "448": "1", + "299": "-159447/16384", + "472": "3/8", + "3": "-54933/8192", + "1137": "56981/8192", + "1205": "8221/512", + "1132": "179/64", + "1075": "-907/16", + "507": "15921/256", + "1306": "-659/2048", + "1212": "-98327/1024", + "1178": "90757/4096", + "439": "383/128", + "992": "12499/1024", + "775": "-155157/8192", + "619": "-50517/16384", + "1125": "121995/2048", + "281": "-293441/32768", + "1182": "-12037/256", + "551": "26061/4096", + "1340": "24781/8192", + "711": "-25805/4096", + "1002": "-26909/4096", + "1193": "24781/8192", + "1232": "-25805/8192", + "377": "25805/4096", + "640": "-61981/8192", + "1293": "42659/4096", + "1229": "-47851/256", + "1233": "-137389/4096", + "806": "30931/16384", + "1235": "206389/8192", + "1148": "531465/16384", + "1328": "498633/4096", + "1049": "124081/4096", + "1134": "-351/256", + "356": "13813/1024", + "1126": "5611/256", + "1215": "263/64", + "1207": "23085/1024", + "1068": "23597/2048", + "1318": "1623/512", + "1307": "5927/256", + "1240": "7443/512", + "1228": "-193127/4096", + "1221": "467/1024", + "1144": "5575/512", + "1127": "11003/512", + "1121": "193935/2048", + "1109": "-177/512", + "1074": "-467/1024", + "1057": "723/4096", + "1047": "-29109/2048", + "1043": "-5/128", + "1024": "65781/2048", + "1022": "-11999/1024", + "830": "3669/4096", + "791": "-3819/512", + "691": "22223/512", + "639": "2159/64", + "548": "45/2048", + "540": "979/4096", + "537": "-467/2048", + "536": "467/2048", + "523": "-447/128", + "516": "-703/256", + "487": "12889/2048", + "365": "13755/4096", + "343": "-225/256", + "303": "-6843/4096", + "301": "66303/1024", + "295": "225/128", + "265": "-22113/2048", + "252": "19269/1024", + "1064": "-65171/8192", + "752": "-37279/1024", + "545": "11913/512", + "1169": "-8045/512", + "316": "8279/256", + "671": "-3943/64", + "1153": "-355/64", + "1198": "-309/256", + "1201": "71/512", + "553": "3799/256", + "1170": "163785/4096", + "1289": "-6141/256", + "1284": "-3567/512", + "1283": "87421/1024", + "1281": "-3739/128", + "1260": "-131217/16384", + "1259": "-163483/2048", + "1258": "164035/2048", + "1256": "49805/2048", + "1227": "163907/4096", + "1224": "-6461/256", + "1200": "16521/256", + "1187": "-49113/1024", + "1186": "263637/1024", + "1183": "-6149/128", + "1175": "162235/4096", + "1174": "162363/2048", + "1172": "162703/1024", + "1171": "161711/2048", + "1166": "6289/512", + "1164": "113195/1024", + "1162": "4267/256", + "1159": "6157/256", + "1145": "20199/1024", + "1128": "-907/128", + "1122": "-1009/128", + "1112": "-164703/2048", + "1105": "63265/4096", + "1089": "-139809/8192", + "1080": "6149/256", + "1078": "12245/512", + "1055": "-22703/256", + "1046": "7615/512", + "1020": "-188831/2048", + "1013": "7443/1024", + "996": "-66705/8192", + "924": "3799/256", + "913": "22415/2048", + "704": "3731/128", + "695": "1953/32", + "689": "-22985/1024", + "648": "-49899/1024", + "582": "4047/128", + "581": "4047/128", + "572": "-6663/256", + "570": "-6141/512", + "569": "-315417/4096", + "565": "163483/2048", + "564": "-164035/2048", + "563": "-49805/2048", + "560": "154835/4096", + "546": "5677/64", + "534": "528891/2048", + "524": "-154835/4096", + "1463": "-1635/256", + "1243": "-1635/128", + "501": "-20231/512", + "497": "3567/128", + "490": "68257/512", + "470": "-4109/64", + "468": "-6631/256", + "451": "1635/128", + "392": "-6673/512", + "372": "3791/32", + "352": "7571/512", + "340": "725/16", + "126": "15761/1024", + "21": "7591/128", + "290": "-55/32", + "268": "-473/512", + "1001": "-187/128", + "286": "91/128", + "586": "741/1024", + "554": "741/1024", + "280": "-709/1024", + "726": "-837/512", + "697": "677/512", + "332": "-741/512", + "333": "741/256", + "249": "741/256", + "173": "-1265/1024", + "1106": "1583/512", + "672": "32387/1024", + "1010": "-30529/16384", + "1004": "1435/1024", + "1244": "-1563/512", + "1026": "21197/1024", + "679": "1499/1024", + "568": "-1499/2048", + "526": "-1135/1024", + "562": "1563/1024", + "1319": "-34091/1024", + "1216": "2763/2048", + "1090": "3515/1024", + "1157": "31/32", + "264": "-31/32", + "1141": "-195/128", + "376": "117/256", + "248": "-467/256", + "578": "-57/32", + "1274": "209/64", + "1006": "51/16", + "464": "17101/256", + "502": "371/256", + "1136": "-43/128", + "573": "-35833/4096", + "1202": "-2037/64", + "1341": "-4111/256", + "1334": "-2017/128", + "1329": "747/128", + "1309": "-9805/512", + "1302": "-2033/64", + "1295": "4279/256", + "1294": "-389/64", + "1273": "-445/512", + "1272": "37/128", + "1262": "305/128", + "1245": "46807/1024", + "1210": "-4279/512", + "1204": "-25/512", + "1191": "-425/4096", + "1188": "-25/2048", + "1160": "405/256", + "1139": "197/64", + "1118": "717/512", + "1111": "389/256", + "1073": "-389/256", + "1070": "-5/128", + "1058": "-43/128", + "1050": "4103/64", + "1044": "-43/128", + "1042": "199/256", + "1041": "-8137/128", + "1033": "46807/2048", + "1003": "-27/256", + "995": "-7893/512", + "901": "-389/4096", + "810": "46807/2048", + "757": "389/128", + "733": "-389/2048", + "643": "389/512", + "635": "4279/512", + "535": "107/256", + "531": "-91/256", + "527": "46807/2048", + "504": "171/512", + "498": "261/512", + "474": "-389/512", + "467": "-54017/512", + "466": "16601/128", + "359": "5/512", + "312": "-7541/512", + "279": "59/256", + "276": "91/128", + "338": "251/256", + "1184": "-1/128", + "1059": "-23/128", + "1234": "-1/8", + "1138": "-55/128", + "1100": "11/32", + "1077": "-1/16", + "1065": "-1/8", + "1016": "-1/4", + "997": "-1/32", + "529": "-1/16", + "488": "-1/4", + "205": "-31/32", + "1161": "-5/16", + "1317": "-9/8", + "1298": "23/16", + "1195": "5/4", + "1181": "-63/128", + "1180": "7/32", + "1177": "-119/128", + "1176": "91/128", + "1081": "-7/8", + "1079": "7/8", + "1031": "-7/32", + "1019": "7/4", + "1011": "1/2", + "732": "-27/64", + "583": "7/16", + "580": "-15/16", + "521": "1", + "517": "11/32", + "458": "21/64", + "457": "-63/256", + "456": "7/4", + "447": "7/8", + "446": "-7/8", + "443": "-7/16", + "442": "7/4", + "441": "-7/4", + "438": "-5/4", + "437": "-7/4", + "434": "-7/16", + "431": "-7/8", + "429": "-7/8", + "428": "-7/8", + "427": "35/64", + "426": "-91/64", + "420": "-7/4", + "418": "-7/8", + "417": "133/128", + "416": "21/128", + "415": "3/4", + "398": "-5/32", + "396": "-9/32", + "380": "-5/16", + "367": "7/4", + "328": "13/16", + "263": "5/2", + "262": "3/2", + "254": "-133/64", + "228": "7/8", + "188": "1/2", + "421": "1/4", + "236": "1/4", + "287": "1/16", + "600": "1/2", + "599": "1/4", + "1300": "3/32", + "1277": "-5/16", + "1206": "7/64", + "1173": "-7/256", + "1158": "1/16", + "1154": "-1/16", + "1152": "1/8", + "1142": "1/32", + "1129": "1/32", + "1120": "-1/4", + "716": "1/8", + "709": "-1/8", + "681": "-17/64", + "665": "1/64", + "655": "1/8", + "608": "-5/8", + "574": "7/64", + "571": "7/32", + "552": "1/16", + "518": "1/32", + "513": "-1/32", + "512": "1/64", + "511": "1/64", + "510": "-1/32", + "1110": "-1/8", + "1097": "1/16", + "1096": "1/16", + "506": "-1/16", + "486": "-7/32", + "479": "-1/16", + "478": "-1/8", + "476": "31/64", + "465": "-1/16", + "414": "3/64", + "379": "1/4", + "370": "1/8", + "358": "-1/16", + "354": "-3/16", + "342": "-1/16", + "296": "-1/32", + "294": "1/8", + "292": "5/4", + "283": "-1/4", + "274": "1/8", + "592": "-1/2", + "344": "-2", + "231": "1", + "482": "-1/8", + "625": "-1/2", + "473": "-1/2", + "1008": "-1/8", + "272": "-1/2", + "475": "1/2", + "1034": "3/16", + "1143": "1/2", + "575": "1/16", + "541": "-1/8", + "539": "-1/8", + "538": "-1/8", + "525": "1/4", + "491": "-3/8", + "260": "1/2", + "300": "-1/8", + "1084": "-1/4", + "1072": "-1/4", + "1088": "1/2", + "1104": "1" + }, + "paid_delta": { + "1": 4, + "2": -2 + } +} diff --git a/research/p104-funded-cohort-split/WORD.json.gz b/research/p104-funded-cohort-split/WORD.json.gz new file mode 100644 index 0000000000..bbf1b6aed7 Binary files /dev/null and b/research/p104-funded-cohort-split/WORD.json.gz differ diff --git a/research/p104-funded-cohort-split/adapt.py b/research/p104-funded-cohort-split/adapt.py new file mode 100644 index 0000000000..0c7a35719d --- /dev/null +++ b/research/p104-funded-cohort-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(".003638942433483")') + 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-cohort-split/construct.py b/research/p104-funded-cohort-split/construct.py new file mode 100644 index 0000000000..748bfe2be2 --- /dev/null +++ b/research/p104-funded-cohort-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-cohort-split/inputs/pr7116.tar b/research/p104-funded-cohort-split/inputs/pr7116.tar new file mode 100644 index 0000000000..6aa112532c Binary files /dev/null and b/research/p104-funded-cohort-split/inputs/pr7116.tar differ diff --git a/research/p104-funded-cohort-split/price.py b/research/p104-funded-cohort-split/price.py new file mode 100644 index 0000000000..7c47ea963c --- /dev/null +++ b/research/p104-funded-cohort-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/'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 #7116 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-cohort-split/source.py b/research/p104-funded-cohort-split/source.py new file mode 100644 index 0000000000..054b3d9477 --- /dev/null +++ b/research/p104-funded-cohort-split/source.py @@ -0,0 +1,56 @@ +"""Authenticate #7116's complete source closure and reconstruct #7115 native. +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 #7116 export') + old_path=list(sys.path) + with tempfile.TemporaryDirectory(prefix='p104-funded-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('funded_composition_inputs',parent/'inputs.py') + try: + with imports.sources() as (sources,work):yield sources,parent,work + finally:sys.path[:]=old_path + +@contextmanager +def sources(): + with bundles() as (parts,composition,work): + parent=parts[7115];original=load('funded_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('funded_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 #7115 native byte') + need(sha256(canonical(word)).hexdigest()=='ae30929ff3b5f6b49a5edac78e2164acfbf809113d0b9f03249ef940dd7b2491','Exact current native') + yield vendor,archive,rank9,bundle,parent,word diff --git a/research/p104-funded-cohort-split/split.py b/research/p104-funded-cohort-split/split.py new file mode 100644 index 0000000000..5407e8959b --- /dev/null +++ b/research/p104-funded-cohort-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-cohort-split/support.py b/research/p104-funded-cohort-split/support.py new file mode 100644 index 0000000000..192cd38d27 --- /dev/null +++ b/research/p104-funded-cohort-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']['448']='2' + controls['wrong_prefix']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['b']['448']='1' + 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))==(373,9),'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 (448,1205,472): + 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_COHORT_NATIVE',source_head='e63533f866455aa5cbc6c405770c31126d76e340', + 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()