diff --git a/research/p104-recharted-rank8-split/APPLICATION.md b/research/p104-recharted-rank8-split/APPLICATION.md new file mode 100644 index 0000000000..3e9fe6d902 --- /dev/null +++ b/research/p104-recharted-rank8-split/APPLICATION.md @@ -0,0 +1,29 @@ +# Conditional application of the rechart and added helper split + +This applies Rohan Arun's #7113 component proof and the retained changed-native adapters to the exact #7122 rechart plus this additional rank-eight split. The full frozen source closure remains intact. PROOF.md supplies the source-specific normalized-coordinate rechart argument and the arbitrary-input helper replacement. Both stages' target/paid changes are recounted; no source's numeric receipt substitutes for current verification. The five assumptions and selected completed BIT predecessor remain. The 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. The current substitutions follow. + +## Native and caller operator substitution + +Rohan Arun's rechart changes seven helper inputs and 22 public scalar contact charts, preserves scalar coefficients/order and rebuilds every causal public transport. This removes four paid MOVEs per native while changing both paid and target rank masses by seven. The additional split neutrally advances 454's 757→924 MOVE and splits its 3→246 rank-eight target into 3→924 (rank 7) and 924→246 (rank 1). It adds 22 ADDs + 4 SCALEs and one fresh input. All owned transitions/lifetimes are retained. The normalized-coordinate rechart proof and the exact prefix/suffix relations with boundary/cut bases 7/6 are in PROOF.md. Its complete forward and adjoint replays include every owned row. All 3,048 current paid/helper chart pairs and 104 main boundary pairs are then rebuilt with the pinned compiler and distinct signed-Pauli/absolute-phase interpreter. For these Clifford maps, the signed Pauli action fixes the operator up to global phase, which the exact Gaussian check fixes. Thus every column of each chart map is determined. The fresh replay includes a deliberately wrong absolute phase. + +The unchanged 17-stage caller has five noncommuting quarter turns and twelve padding turns in inverse pairs. Its grouped idle bases lie over Z[1/30]. Its exact rational and integer Laurent engines agree on all 72 output fields for every formal central/body variable. In the physical substitution, seventeen disjoint eight-axis stage blocks and nine central axes use ambient 145. For each invocation, exchange the eight native complement axes with the fresh stage block while fixing the routed central axis and spectator axes. The phase-polynomial checks verify both directions. Literal A and B routes then apply commuting body operators on disjoint stage blocks. + +A signed rank-nine idle uses one positive rank-nine recursive request plus the charged ordinary conjugation/phase implementing the inverse on the protected central axis. Current finite signed-child checks cover widths 1,2,3; the symbolic phase geometry supplies the disjoint-axis substitution. The ordered occurrence digest is recomputed from the literal caller and current native geometry. It binds 13,600 native contact boundaries, 110,655 paid positions and 22,291 productive fields. Main-owner aliasing is rejected. Allocate 18,547 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,491 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 1172, giving c=2344. This is recomputed from the current word and caller; #7122's allowance was 2344. 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=16495300000000000000000. The regenerated compiler gap is 1/100000000000000000. Every rounded caller bound, outer and fixed-tape gate is checked with these current values. 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,763,024 includes the caller and native conversion services. It is distinct from the physical-machine bound. The fresh raw-occurrence counts give 1,146,361 native scalar macro inputs, 117,856 caller macro inputs and 58,182 conversions. The retained conservative factor 32 gives 42,316,768 scalar services; with the reviewed 2²⁰ service constant this is 44,372,347,322,368 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,740 monomial map slots. At actual ambient 145, the retained elementary bound 4(145+1)² is 85,264 records per map, hence at most 25,471,767,360 elementary records per raw occurrence. Use actual owner widths and these finite coefficients in the same fixed-tape stock and movement envelopes from the selected review. The positive compiler/outer slack permits enlarging the eventual cutoffs. This is a conditional asymptotic substitution, not an enumerated machine trace. + +The recomputed complete recurrence has the bracket and claim in README.md; both exact price engines, the compiler and 54 strict plus 4 functional outer inequalities pass. These checks establish the stated conditional component application under the five assumptions. Independent mathematical review, formal-kernel validation and maintainer admission are separate obligations. + +Credit Rohan Arun for the #7113 proof and implementation, Douglas Colkitt and the #7000 application reviewers, the retained compiler/precision/source authors, and the complete lineage in README.md. Adapted for this exact rechart plus helper split, retaining all peer and predecessor credit, by dillona with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-recharted-rank8-split/DISCOVERY.json b/research/p104-recharted-rank8-split/DISCOVERY.json new file mode 100644 index 0000000000..9f8dadc2b5 --- /dev/null +++ b/research/p104-recharted-rank8-split/DISCOVERY.json @@ -0,0 +1,93 @@ +{ + "source_head": "98aad9eb0e7d7f985622a35c7981695fe680c68a", + "scope": "Existing frames and contact-free cohorts on changed group3\u2192246 after7122. Complete kernels plus basis nominations, not exhaustive rational support/cost optimization.", + "counts": { + "systems": 2739, + "saved": 839, + "pairs": 183, + "hits": 3, + "classes": { + "F1zero": 657, + "F2zero": 60, + "witness": 122 + }, + "rescued": 0, + "budget_reject": { + "3": 160, + "5": 3, + "8": 1, + "7": 12 + }, + "best_budget": { + "cut": 42018, + "frame": 924, + "cost": 0.0, + "gain": 0.010918442909852999, + "paths": [ + { + "role": 454, + "lo": 40015, + "hi": 42239, + "frame": 924, + "old": 757, + "new": 924, + "moves": [ + 42238 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 1, + 0 + ], + "cost": 0.0, + "private": false, + "neutral": true + }, + { + "role": 1208, + "lo": 39997, + "hi": 42019, + "frame": 924, + "old": 924, + "new": 246, + "moves": [ + 42017 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 0, + 1 + ], + "cost": 0.0, + "private": false, + "neutral": true + } + ], + "paid_roles": 0 + } + }, + "chosen_index": 1, + "constructed_indices": [ + 1 + ], + "unbuilt_indices": [ + 0, + 2 + ], + "unrun_declared_groups": [ + [ + 3, + 120 + ], + [ + 3, + 127 + ] + ], + "stop_reason": "First declared group found smooth positive nomination; verification takes priority.", + "local_only": "Discovery scripts/negative scopes remain local. Public WITNESS and constructor are independent of search. Full incumbent and candidate evidence is in the registered package." +} diff --git a/research/p104-recharted-rank8-split/ENVIRONMENT.json b/research/p104-recharted-rank8-split/ENVIRONMENT.json new file mode 100644 index 0000000000..0eccbccef4 --- /dev/null +++ b/research/p104-recharted-rank8-split/ENVIRONMENT.json @@ -0,0 +1,14 @@ +{ + "initial_python": "3.14.7", + "initial_platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "registered_replay": { + "python": "3.12.16", + "platform": "macOS-27.0.1-arm64-arm-64bit", + "result": "PASS both complete commands; every native and composition receipt field matched" + }, + "dependencies": "Python standard library", + "interpreter_origin": "Official Astral python-build-standalone release20261026; isolated /tmp installation", + "interpreter_archive_sha256": "fbf4afef53c2a6b72bb741bc06d5671a9dfaf87bd84e5aa73ac9b3d0d589f14e", + "hosted_ci": "Not yet published; no hosted scientific pass claimed.", + "completed_utc": "2026-11-10T21:15:02.771080+00:00" +} diff --git a/research/p104-recharted-rank8-split/INPUTS.json b/research/p104-recharted-rank8-split/INPUTS.json new file mode 100644 index 0000000000..c7152467bc --- /dev/null +++ b/research/p104-recharted-rank8-split/INPUTS.json @@ -0,0 +1,63 @@ +{ + "head": "98aad9eb0e7d7f985622a35c7981695fe680c68a", + "pr": 7122, + "prefix": "research/p104-global-input-rechart", + "archive": "inputs/pr7122.tar", + "archive_sha256": "5c3ed6ee7454f95c02644f3937b6c4efef8af0428ec4a11aa4e7c286d8e148f8", + "files": [ + { + "path": "research/p104-global-input-rechart/CHANGES.json", + "size": 1332, + "sha256": "f9d8ced5926a73888363f557676c29e60d1b23a349df539a8a447d99dba00f86", + "git_blob": "ef91519140eb3cca0bf1407e1145c83a8b9b0d10" + }, + { + "path": "research/p104-global-input-rechart/EARLY-RESULT.json", + "size": 6525, + "sha256": "2a8cd0ccae85b3a59758cffb8ce6835ca6274d19a9dd0e25f037786228af0f52", + "git_blob": "9eb49a84e7ad49e887ff714673a9af4ce68fe4e5" + }, + { + "path": "research/p104-global-input-rechart/INPUTS.json", + "size": 4793, + "sha256": "9f12e123c452c4f189f6a120ee02abef0fe23b3cd4283fa00f444eb357064308", + "git_blob": "4b5da8a51946e11001482b0b817549a651d9a594" + }, + { + "path": "research/p104-global-input-rechart/README.md", + "size": 2028, + "sha256": "2e45016314965df4bdca17125fedfe422602a47209f5f3092a0bfbc064e4befc", + "git_blob": "d3063681d42243daa236a225b382d0b83cb06976" + }, + { + "path": "research/p104-global-input-rechart/WORD.json.gz", + "size": 365572, + "sha256": "7690bdbd0180c9212693c600e7a54c2d391f27b293ac06826dc5a961b2dc2829", + "git_blob": "c57f1d11af1cc35a8fd9403809c737e4fba99c06" + }, + { + "path": "research/p104-global-input-rechart/construct.py", + "size": 1957, + "sha256": "0a83206f3b5b046839b52a6f137462ade89c9f3212a22c0c2991b517227ae2ae", + "git_blob": "abab5b5b7c6e218c52d6e96284bc2c9337a7b336" + }, + { + "path": "research/p104-global-input-rechart/inputs/pr7121.tar", + "size": 8755200, + "sha256": "dab5a4de50253d47234930cdef7c2f04b4d283acdf3bd8c636cb3279afabc35c", + "git_blob": "0fe091323367ecd089fcad28a8721533876ca381" + }, + { + "path": "research/p104-global-input-rechart/source.py", + "size": 2686, + "sha256": "5e6888f42ebdacc5ab1938c3ea5a392f4f7a8abad62018dc5df42523e2e1a2d7", + "git_blob": "1ab8c136ec4bb2ba01ccf245b1a88a8895869abc" + }, + { + "path": "research/p104-global-input-rechart/verify_early.py", + "size": 2524, + "sha256": "3eab4e4c9aeefef837d31e95152e0c98aebf40aac4a95dc7c19fa26e506cd492", + "git_blob": "b7bd7ad3e3c14fc69694ac405a70a97f7ff0ee92" + } + ] +} diff --git a/research/p104-recharted-rank8-split/NATIVE-RESULT.json b/research/p104-recharted-rank8-split/NATIVE-RESULT.json new file mode 100644 index 0000000000..049ab968b8 --- /dev/null +++ b/research/p104-recharted-rank8-split/NATIVE-RESULT.json @@ -0,0 +1,3089 @@ +{ + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "new_pairs": [ + [ + 3, + 430 + ], + [ + 3, + 924 + ] + ], + "rechecked_pairs": [ + { + "columns": 512, + "pair": [ + 3, + 246 + ], + "rank": 8 + }, + { + "columns": 512, + "pair": [ + 3, + 430 + ], + "rank": 2 + }, + { + "columns": 512, + "pair": [ + 3, + 924 + ], + "rank": 7 + }, + { + "columns": 512, + "pair": [ + 924, + 246 + ], + "rank": 1 + } + ], + "wrong_phase_rejected": true + }, + "controls": { + "incomplete_retiming_interval": true, + "insufficient_fractional_grid": true, + "insufficient_odd_grid": true, + "missing_cut_correction": true, + "missing_final_basis": true, + "missing_initial_basis": true, + "missing_peer_contact_rechart": true, + "missing_peer_input_rechart": true, + "missing_successor_correction": true, + "wrong_boundary_direction": true, + "wrong_boundary_functional": true, + "wrong_cut_frame": true, + "wrong_paid_declaration": true, + "wrong_prefix": true, + "wrong_successor_frame": true, + "wrong_suffix": true, + "wrong_target_ranks": true + }, + "derived_grid": { + "coefficient_visits": 15006143, + "fractional_bits": 24, + "mass_witness": [ + 64746, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "1630603680282225/16384", + "unscaled_maximum_mass": "7247127467921/81920" + }, + "forward": { + "coefficient_positions": 2377764, + "fractional_bits": 24, + "grid": 1125, + "rows": 1542 + }, + "gate": { + "BIT_margin": "12604003125593/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16495300000000000000000", + "alpha": [ + 0.9999999999999992, + 0.9999999999999992 + ], + "claim": "455081246093/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8823111864110287, + 0.8823111864110287 + ], + "derivative_upper": -407402.0006096018, + "gamma": [ + 0.9499415560287295, + 0.9499415560287295 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364064996874407/100000000000000000": [ + "31054416013388518742820611363980561839184611104931257209256836072989800749739/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124217664053554074971282445455922247356738444419725028837027344291959203000919/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455081246093/125000000000000": [ + "24843532810710357674541976216779454958932438532345617383890614042840301317969/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124217664053551788372709881083897274794662192661728086919453070214201506591823/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2234, + "moment_margin_float": { + "364064996874407/100000000000000000": [ + 2.630272983985002e-10, + 2.630272983985002e-10 + ], + "36406499687447047769836358585949/10000000000000000000000000000000000": [ + -2.309297999393172e-29, + -2.309297999393172e-29 + ], + "9101624921861761942459089646487/2500000000000000000000000000000000": [ + 1.834319447035637e-29, + 1.834319447035637e-29 + ] + }, + "moment_margins": { + "364064996874407/100000000000000000": [ + "13151364919925009566990097055429144742104192016454905077093887285493907/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "657568245996250478349504852771457237105209600822745253854694365314579/2500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36406499687447047769836358585949/10000000000000000000000000000000000": [ + "-577324499848293041531604083823287831630595186693313/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1154648999696586083063208167646575663261190352354767/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9101624921861761942459089646487/2500000000000000000000000000000000": [ + "458579861758909279610518282850288665202214690177959/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "917159723517818559221036565700577330404429401500961/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "9101624921861761942459089646487/2500000000000000000000000000000000", + "36406499687447047769836358585949/10000000000000000000000000000000000" + ], + "tested": "364064996874407/100000000000000000", + "written_log_power": 2235 + }, + "grid": { + "dyadic_height": 24, + "maximum_scaled_mass": "1630603680282225/16384", + "odd_divisions": { + "ADD": 5231, + "SCALE": 69 + }, + "odd_grid_lcm": 1125, + "opcodes": { + "ADD": 63624, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6287, + "SCALE": 3700 + }, + "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": 4028, + "2": 842, + "3": 819, + "4": 232, + "5": 333, + "6": 16, + "7": 11, + "8": 6 + } + }, + "invoice": { + "P": { + "1": 72888, + "16": 416, + "2": 15156, + "24": 416, + "3": 14742, + "32": 416, + "4": 4176, + "40": 416, + "48": 416, + "5": 5994, + "56": 416, + "6": 288, + "64": 416, + "7": 198, + "8": 780, + "9": 32 + }, + "S": 1520, + "T": { + "1": 324, + "145": 208, + "17": 416, + "2": 324, + "25": 416, + "3": 846, + "33": 416, + "4": 3906, + "41": 416, + "49": 416, + "5": 1332, + "57": 416, + "6": 756, + "65": 416, + "7": 324, + "73": 416, + "8": 954, + "9": 11288 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036406499687447047769836358585948442685520743849444880214901972178", + "raw_crossing": "0.0036406499687447047769836358585948442685520743849444880214901972178" + }, + "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": 73720, + "helpers": { + "1": 18, + "2": 18, + "3": 47, + "4": 217, + "5": 74, + "6": 42, + "7": 18, + "8": 53, + "9": 604 + }, + "lifetimes": 54, + "owned_peak": 43, + "paid": { + "1": 4028, + "2": 842, + "3": 819, + "4": 232, + "5": 333, + "6": 16, + "7": 11, + "8": 6 + }, + "public": 1491, + "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": 851501248, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 148498752, + "odd_divisions": { + "ADD": 5231, + "SCALE": 69 + }, + "per_input_conversion": 2791152, + "raw_upper": 833541840, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2182, + "moves": 6287, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9885000, + "scalar_upper": 1990320 + }, + "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": "77482064519477492877345882155072340032574220477639737093900851259940249312392762411914793924788220848000576167600278195887774439317989728099179785192623010292838720537886878445373257636457845850072983482355506031154698179853959053430185443520880969781152030494121817845230543355100251431798750332962461512101753643/236574025616993083824920739000090624000000000000000000000", + "strict_power_of_two": 856, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "49933630000095334090753753139320204789004846492843286818470708692634496985666575667012930057776970044181867557184766727808413615714883727280877596495054102463916985262904847924512769734253905679482338326845998173553644565450517426593144842742667734481034305599601317132215717452484194181860010742723772827476746618463/1135555322961566802359619547200434995200000000000000000000", + "strict_power_of_two": 863, + "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": "1517515679182198924034577432022586317234847044351638365847309596003951132160868512030200616997928106376771425109554950240852288923683184559813784269750605022943987734068653460591509394844729790528571833081096260764518189108430075733617011811989288333922111932075099401822130615366052952216248421562200698556698564921337/94629610246797233529968295600036249600000000000000000000", + "strict_power_of_two": 872, + "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": "49933630000095334090753753139320204789004846492843286818470708692634496985666575667012930057776970044181867557184766727808413615714883727280877596495054102463916985262904847924512769734253905679482338326845998173553644565450517426593144842742667734481034305599601317132215717452484194181860010742723772827476746618463/1135555322961566802359619547200434995200000000000000000000", + "strict_power_of_two": 863, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "26629209662837109827316260265236130735389175299183268306220644365193658585032787279994594251932542923823970864612488751312569864706222463213382026317554803508935241864914060162290998852048177062065301258922273657277371982811389050891876552885702304265835324486103133077795999657405619399555052799278602591223555630897431541303020356460648884662575771772951839131799058636962747127180697147655291230106742928750273161327813933095955156693041104653/81983305073188036898332404126324460286112199797016435889798262030336000000000000000000000000000000000000000000", + "strict_power_of_two": 1115, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19638, + "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": "77482064519477492877345882155072340032574220477639737093900851259940249312392762411914793924788220848000576167600278195887774439317989728099179785192623010292838720537886878445373257636457845850072983482355506031154698179853959053430185443520880969781152030494121817845230543355100251431798750332962461512101753643/236574025616993083824920739000090624000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "49933630000095334090753753139320204789004846492843286818470708692634496985666575667012930057776970044181867557184766727808413615714883727280877596495054102463916985262904847924512769734253905679482338326845998173553644565450517426593144842742667734481034305599601317132215717452484194181860010742723772827476746618463/1135555322961566802359619547200434995200000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "49933630000095334090753753139320204789004846492843286818470708692634496985666575667012930057776970044181867557184766727808413615714883727280877596495054102463916985262904847924512769734253905679482338326845998173553644565450517426593144842742667734481034305598465761809254150650124574634659575747523772827476746618463/1135555322961566802359619547200434995200000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "77482064519477492877345882155072340032574220477639737093900851259940249312392762411914793924788220848000576167600278195887774439317989728099179785192623010292838720537886878445373257636457845850072983482355506031154698179853959053430185443520880969781152030494121817845230543355100251431798750332962461512101753643/236574025616993083824920739000090624000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "49933630000095334090753753139320204789004846492843286818470708692634496985666575667012930057776970044181867557184766727808413615714883727280877596495054102463916985262904847924512769734253905679482338326845998173553644565450517426593144842742667734481034305599601317132215717452484194181860010742723772827476746618463/1135555322961566802359619547200434995200000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "9818254090144898938713235620089841358071262274516130729953905463782901335162710819613062680923169226701649078367863162539326516353100873/43317997854674026579270154846208000000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "28144538550813284976973246045977348063110996336510909600788084113423384588852670755420655289046056546199744349822540565857643808582646892644831867/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "363201725372700881407708785051754863373137843642678025056159262251859362686274908866876875375122797246282328221321904697135718142410104305420722566451559/138617593134956885053664495507865600000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "1290079693750127196872273115211490636618784565611034851075977419554243679261891400936001550257032790614159917550287940774841118888230249526059848350704924646365823/924117287566379233691096636719104000000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "2315260371572471828340073994840074831477868499366645066539205004523754620803079908586932206456894974604368239574757687409019913628060265937585764645669459431132754755538569/693087965674784425268322477539328000000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "35108218486247243690020522543710189519940900952927282858774685614324281193035340014400644227019832789709018094384387881864064426766644395560394735351198592264541890541751700265231831/4435762980318620321717263856251699200000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "144899551047274269516139742601301756601552885566898127448579659737829637349793391998091900003982219765153970983140201027749617895809917572979889780285066975400999559226221158929068795912231337/1848234575132758467382193273438208000000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "1568408255290676697596875786591002289825509424024040930169337413640996324495871266769770624554939702230710062035371335914313676023161984130101149831850631546359445784938367226693975906006503348686844633/11089407450796550804293159640629248000000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "45013213550766564848544173241636699665768179795634864115323816874862984069919903673212880494891935368197642112568067035684503750260184322329292999582780704232280836755965760732052319393805379861490285293155116933844066233307018308375442237787369/2772351862699137701073289910157312000000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "561500213134074161421721243727817695685050592521876184087570172087061828278066243397584689679115787011939312251734613623255516181174554376176925947372562593765303087323927662883997983449804854427816137916914001834816186365933172841247198266211445481158391/44357629803186203217172638562516992000000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "2504023702467432471172044182491592241858629857582893980840866848119146052681481763998152412647198180638186216352848475092022399143153688906278541901473654506966030465212655854935694554158355368586081554787195543204371987469317984117322677591898185252083762996921871/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "269312597805985078934506937884513995893845730930150454315696174396455154616637178640933594896702984244859503340784035585047809095182931608350540058465634567746614763494053697379209991614389885525765306481679573855066799890043334814536073275248835270254008274094701402335109/19714502134749423652076728250007552000000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "1652538227220649375684821129871841469837479623634221056676439426718622516083713842919442034689940264175241594776714285991166493937376786372447641410580338702431320301370125194103627050693956039328008848451606091731768243642035116846279969436569724511227899715909898271899326151854567/354861038425489625737381108500135936000000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "163074958454502863788773709977505329317691327353485294738184088358585649818391959827440678282378436777235512133545837280790411255092796926125500716549478291083855127312055751997738974729368639144048393837287113580791815747201660629883178663762311758838098170576439619813580626167488215365881/177430519212744812868690554250067968000000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "79662933402983993582518441871933626358641592464642191360368395416423287866623152034020827430081151696196573099983637666647081853341186632327849362228207615451886300780781145852568890083848102017608972204476822007471552210062310905616426852352360059202854595081334486793960464030355264331403820129199/1419444153701958502949524434000543744000000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "164507681064776804330527117530079210855983034397496045834963879687613655103432732324260743891534070207060927510056474445367356458823999891373425878851419000934052351409747688510110727058366522132338082660558659350898274970653845745443966571070148557391518622523475350534658962384926892454560947761438186801/283888830740391700589904886800108748800000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "77482064519477492877345882155072340032574220477639737093900851259940249312392762411914793924788220848000576167600278195887774439317989728099179785192623010292838720537886878445373257636457845850072983482355506031154698179853959053430185443520880969781152030494121817845230543355100251431798750332962461512101753643/236574025616993083824920739000090624000000000000000000000", + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "event": 4982, + "stage": 18 + } + ], + "physical_main_inputs": 3952, + "sites": { + "ADD": 4102, + "IDLE_ODD": 4, + "IDLE_ONE": 96, + "J": 18, + "LAMBDA": 214, + "QUERY": 4, + "SCALE": 298, + "SWAP": 376, + "noninteger_scalar": 1562 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 258, + "witness": { + "cut": 73720, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "strict_power_of_two": 260, + "witness": { + "cut": 72970, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 258, + "witness": { + "cut": 72970, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73720, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63624, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6287, + "SCALE": 3700 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1491, + "scalars": { + "dyadic": 62025, + "integer": 39299, + "noninteger": 28026, + "odd": 5300 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 15006143, + "dyadic_height": 24, + "mass_witness": [ + 64746, + "stored add" + ], + "maximum_scaled_mass": "1630603680282225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + } + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "23370683394937309359373208380616787554492084336339401703410349271162069359265939/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "23370683394937309359373208380616787554492084336339401703410349271162069377986701/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003640649968744", + "gain": "0.000001128030229", + "gain_exact": "1128030229/1000000000000000", + "independent_raw_bracket": [ + "0.00364064996874470477698363585859484", + "0.00364064996874470477698363585859485" + ], + "previous_claim": "727904387703/200000000000000", + "raw_bracket": [ + "0.0036406499687447047769836358585948", + "0.0036406499687447047769836358585949" + ] + }, + "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": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38" + }, + "source_head": "98aad9eb0e7d7f985622a35c7981695fe680c68a", + "status": "PASS_P104_RECHARTED_RANK8_NATIVE", + "word_canonical_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38" +} diff --git a/research/p104-recharted-rank8-split/PEER-EARLY.json b/research/p104-recharted-rank8-split/PEER-EARLY.json new file mode 100644 index 0000000000..9eb49a84e7 --- /dev/null +++ b/research/p104-recharted-rank8-split/PEER-EARLY.json @@ -0,0 +1,200 @@ +{ + "status": "PASS_EXACT_NATIVE_AND_PRICE_ONLY", + "word_sha256": "880a2402e01a6a92ce8bfde2046fa6375014b16ca4f89d6cc6f5cead621e54f8", + "native": { + "public": 1490, + "events": 73694, + "paid": { + "1": 4028, + "2": 842, + "3": 819, + "4": 232, + "5": 333, + "6": 16, + "7": 11, + "8": 6 + }, + "helpers": { + "1": 17, + "2": 18, + "3": 47, + "4": 217, + "5": 74, + "6": 42, + "7": 17, + "8": 54, + "9": 604 + }, + "rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + }, + "owned_peak": 43, + "lifetimes": 54, + "bad_inputs": [] + }, + "native_delta": { + "T": { + "4": -2, + "5": 2, + "7": -1, + "8": -3, + "9": 4 + }, + "P": { + "1": -6, + "2": 1, + "3": 1, + "4": -8, + "5": 8 + } + }, + "invoice": { + "P": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 289, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 289, + "73": 208, + "8": 918, + "9": 10684 + }, + "empty_root_credits": 0 + }, + "gate": { + "claim": "1820380687071/500000000000000", + "tested": "364076137414207/100000000000000000", + "raw_bracket": [ + "36407613741422058608084968767767/10000000000000000000000000000000000", + "4550951717677757326010621095971/1250000000000000000000000000000000" + ], + "moment_margins": { + "36407613741422058608084968767767/10000000000000000000000000000000000": [ + "705662820921648342557504615682160171790091569745373/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "882078526152060428196880769602700214737614471802137/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "4550951717677757326010621095971/1250000000000000000000000000000000": [ + "-176891770204375840322306566385618998312040009924017/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-176891770204375840322306566385618998312039990531611/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364076137414207/100000000000000000": [ + "2637124623579151041814188174130498146641124433592058965465953775945151/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "527424924715830208362837634826099629328224886718411793093190759059357/10000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "moment_margin_float": { + "36407613741422058608084968767767/10000000000000000000000000000000000": [ + 3.528314104608242e-29, + 3.528314104608242e-29 + ], + "4550951717677757326010621095971/1250000000000000000000000000000000": [ + -3.537835404087517e-30, + -3.537835404087517e-30 + ], + "364076137414207/100000000000000000": [ + 5.274249247158302e-11, + 5.274249247158302e-11 + ] + }, + "derivative_upper": -382152.98856900504, + "alpha": [ + 0.9999999999999998, + 0.9999999999999998 + ], + "gamma": [ + 0.9407717523209109, + 0.9407717523209109 + ], + "delta": [ + 0.9016746922369976, + 0.9016746922369976 + ], + "minimum_log_power": 2234, + "written_log_power": 2235, + "compiler_gap": "1/100000000000000000", + "H": "16495300000000000000000", + "BIT_pin": "376669/100000000", + "BIT_margin": "12592862585793/100000000000000000", + "outer": { + "strict_count": 54, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "BIT_just_below_effective_rejected": true + }, + "input_lift": { + "margins": { + "1820380687071/500000000000000": [ + "124221303183246605798157548681067042551641595501913289040898023137931068965231/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "15527662897905825724769693585133380318955199437739161130112252892241383620897/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364076137414207/100000000000000000": [ + "62110651591624446195264618588536884543270343875546256441433555808238909051133/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124221303183248892390529237177073769086540687751092512882867111616477818104221/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "interval_kappa_cap": "376669/100000000", + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + "price": { + "claim_decimal": "0.003640761374142", + "previous_claim": "910025546849/250000000000000", + "gain": "6.59186746E-7", + "gain_exact": "329593373/500000000000000", + "raw_bracket": [ + "0.0036407613741422058608084968767767", + "0.0036407613741422058608084968767768" + ], + "independent_raw_bracket": [ + "0.00364076137414220586080849687677679", + "0.0036407613741422058608084968767768" + ], + "candidate_margin_at_old_upper": [ + "12795153887105283049491190585683761220183312536272534915099696316222039901673577/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "25590307774210566098982381171367522440366625072545069830199392632444079837480431/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "baseline_rejects_new_claim": true + }, + "pending": [ + "fresh integer grid", + "all affected physical chart maps", + "complete caller replay", + "ordinary and precision bounds", + "full source application" + ] +} \ No newline at end of file diff --git a/research/p104-recharted-rank8-split/PEER-STATUS.json b/research/p104-recharted-rank8-split/PEER-STATUS.json new file mode 100644 index 0000000000..50ebfe20a4 --- /dev/null +++ b/research/p104-recharted-rank8-split/PEER-STATUS.json @@ -0,0 +1,17 @@ +{ + "frozen_source_head": "98aad9eb0e7d7f985622a35c7981695fe680c68a", + "later_public_head": "6391d64cd0e37e0988e6b9c41fe13f053ed2c81e", + "checked_utc": "2026-11-10T21:01:00Z", + "same_git_blobs": { + "WORD.json.gz": "c57f1d11af1cc35a8fd9403809c737e4fba99c06", + "CHANGES.json": "ef91519140eb3cca0bf1407e1145c83a8b9b0d10", + "construct.py": "abab5b5b7c6e218c52d6e96284bc2c9337a7b336", + "INPUTS.json": "4b5da8a51946e11001482b0b817549a651d9a594", + "source.py": "1ab8c136ec4bb2ba01ccf245b1a88a8895869abc", + "EARLY-RESULT.json": "9eb49a84e7ad49e887ff714673a9af4ce68fe4e5" + }, + "later_author_status": "PR7122 marked ready; author reports full native/application and registered3.12 replay passed. This package retains its original9-file frozen inputs and supplies its own full combined replay.", + "later_proof_sha256": "ab72bd0aba2d73064f09f05524a0c3ab48d14dfdebb05dbb4c45ff7d0911b034", + "later_proof_url": "https://github.com/rohanarun/integer-mult-bounds/blob/6391d64cd0e37e0988e6b9c41fe13f053ed2c81e/research/p104-global-input-rechart/PROOF.md", + "credit": "Rohan Arun global rechart;1337isnot1337/OpenAI Codex fresh-helper-boundary/discover-cut.cpp alpha-expansion method. No independent replay of the later peer full package is claimed here." +} diff --git a/research/p104-recharted-rank8-split/PROOF.md b/research/p104-recharted-rank8-split/PROOF.md new file mode 100644 index 0000000000..4cc1df01d7 --- /dev/null +++ b/research/p104-recharted-rank8-split/PROOF.md @@ -0,0 +1,116 @@ +# A recharted input enables a further independent helper split + +The complete nine-file export of Rohan Arun's #7122, head +`98aad9eb0e7d7f985622a35c7981695fe680c68a`, is frozen in `INPUTS.json`. +It retains the entire #7121 export and all nested source notices. The replay +reconstructs #7121's word `0a27f1224fdb196602d52d4170bc12b8bde0b9818809e73ecdbdaaa5d3b7adbc` +and the exact #7122 word `880a2402e01a6a92ce8bfde2046fa6375014b16ca4f89d6cc6f5cead621e54f8`. +The copied `rechart.py`, `RECHART.json` and `PEER-EARLY.json` must be byte-identical +to their credited files in that public export. Its early receipt does not +claim a completed physical/application replay. + +Rohan Arun's rechart changes seven helper input frames and 22 public scalar +contact frames. Scalar coefficients and order are retained. The constructor +rebuilds every public causal transport and retains each owned transition and +lifetime. Every contact is cocharted, every public transition is nested and +increasing, and every helper target is strictly productive. Formal MOVE +operations are identities, so the unchanged scalar word has the same +arbitrary-input coefficient operator. The new physical interpretation and +costs still require the complete chart/caller checks in APPLICATION.md. +No free transport or credit from a zero-initialized public helper is assumed. + +In particular, input 1445 moves from chart 105 to chart 3. Its target remains +246, so it can now share a boundary basis with independent helpers +454,1208,1461 in group 3→246, dimensions zero and eight. This basis was not +legal on #7121, where 1445 started at 105. That changed interface is the +reason for this follow-up; the global rechart itself is Rohan Arun's result. + +## Exact causal cut + +Use cut 40552 of the exact #7122 program, just before event 40552. Advance +role 454's single rank-one MOVE, event 42238 from 757 to 924, to this cut. +The declared interval [40015,42239) contains that MOVE and no scalar contact +or source read of 454. Chart dimensions are 6→7. The checker verifies every +role event, source read, interval boundary and old/new paid histogram. +This retiming preserves the scalar operator and the entire paid Counter. +All cut fields and the pivot now occupy chart 924, a strict intermediate +between 3 and 246. + +Writing P for the retimed prefix and S for the suffix, exact rational checks +on every public input and owned row establish + +``` +a = e1461ᵀ − e1208ᵀ/4, +b = e454/3 − e207/3 + 4e1208/3 + 4e1461/3, +c = e1461ᵀ − e1208ᵀ/4 + e454ᵀ − e1445ᵀ/2, +d = e454/3 + 2e1445/3 + 4e1208/3 + 4e1461/3, +aP = c, Sb = d, ab = cd = 1. +``` + +Only c and d must lie in the common helper boundary group. The cut vectors +may also use main role 207, whose chart availability is checked explicitly. +The attributed Ali Romman routine emits these bases: + +``` +G at chart 3: + x454 *= 3 + x1208 -= 4x454/3 + x1445 -= 2x454/3 + x1461 -= 4x454/3 + x454 -= x1208/4 + x454 -= x1445/2 + x454 += x1461 + +J at chart 924: + x454 *= 3 + x207 += x454/3 + x1208 -= 4x454/3 + x1461 -= 4x454/3 + x454 -= x1208/4 + x454 += x1461 +``` + +They satisfy row454(G)=c, Gd=e454, row454(J)=a and Jb=e454. +Their inverses reverse instruction order and invert each operation. Every +scalar in both directions is in the retained 2,3,5-smooth alphabet. + +Apply G⁻¹ at the input boundary, followed by P and J. Coordinate 454 equals +its original independent input because aPG⁻¹=cG⁻¹=e454ᵀ. Retire this field +at 924 and replace its continuation by a fresh arbitrary input z, role 1490. +After J⁻¹, S and G at output boundary 246, the output change is +GSb(z−x454)=Gd(z−x454)=e454(z−x454). Every other endpoint is unchanged. +This uses neither P⁻¹ nor S⁻¹ and retains the owned initialization/erasure +assumptions. The continuing pivot is relabelled to 1490, and owned labels +are shifted by one to preserve disjoint inventories. + +The retained target is 3→924 of rank 7 and the fresh target is 924→246 of +rank 1. Relative to #7122, the split adds 22 ADDs and four SCALEs, with no +added paid positions. The whole combined word has 73,720 events, 1,491 +public fields and 1,091 independent helpers; all 54 owned lifetimes, peak +43, and 23 rises of mass 56 remain unchanged. Its canonical hash is +`34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38`. + +## Complete invoice obligation + +For H_r=r^(1−κ), the incremental signed gain over #7122 is H7+H1−H8>0 +for 0<κ<1. Relative to #7122, ΔP={} and ΔT={1:+1,7:+1,8:−1} per native. +Relative to the fully retained #7121 word, the combined changes are +ΔP={1:−6,2:+1,3:+1,4:−8,5:+8} and +ΔT={1:+1,4:−2,5:+2,8:−4,9:+4}. The signed 17-stage caller multiplies these +changes by 17. Its surplus remains 1424 and empty credit is zero. + +The new scalar bases, fresh input, odd conversions, complete envelopes, +physical maps and ordinary/fixed-tape costs are charged in APPLICATION.md. +The full replay recounts #7121, #7122 and the candidate rather than importing +the peer's reported gain as a cost certificate. A positive local tariff is +not by itself a completed component application or a multiplication theorem. + +Credit 1337isnot1337/OpenAI Codex for the fresh-helper-boundary alpha-expansion +method used by Rohan Arun; credit Rohan Arun for #7122's rechart and #7113's signed caller/application; +Ali Romman for the independent helper and basis identity; Jerry Chen/CubeJerry +for causal/native/invoice/compiler tools; Matarener for complete discovery +kernels and pairing; ToikY for the retained chart-120 pattern, signed sources +and subsequent independent chart-259 reproduction; DreamingOfClouds, +Douglas Colkitt/#7000 reviewers and every retained source notice. This added +split was prepared for dillona with substantial OpenAI Codex assistance; +no subagents. Apache-2.0. diff --git a/research/p104-recharted-rank8-split/README.md b/research/p104-recharted-rank8-split/README.md new file mode 100644 index 0000000000..5358485b09 --- /dev/null +++ b/research/p104-recharted-rank8-split/README.md @@ -0,0 +1,50 @@ +# Conditional κ = 0.003641239650184 from a recharted helper split + +Rohan Arun's #7122 moved helper 1445's input to chart 3. That makes a new boundary basis legal with helpers 454, 1208 and 1461. This package adds a **rank 8→7+1 split** at chart 924, with **no paid-profile increase over #7122**. The complete conditional claim is **0.003641239650184**, a gain of **0.000000478276042** over #7122. All added scalar work and changed application costs are charged. + +The exact #7122 cut 40552 / pivot 454 uses one neutral advance of its 757→924 MOVE. Boundary/cut bases 7/6 add **22 ADDs + 4 SCALEs** and one fresh independent helper. [PROOF.md](PROOF.md) gives the concrete bases, complete arbitrary-input replacement argument and causal interval. The emitted word has 73,720 events, 1,491 public inputs and 1,091 helpers. Owned lifetimes, peak allocation and rise mass are unchanged. + +| Complete signed 17-stage application | #7122 | This construction | +|---|---:|---:| +| Paid positions |110655|110655| +| Productive fields |22274|22291| +| Rank surplus |1424|1424| +| Empty credit |0|0| + +Relative to #7122, ΔP={}, ΔT={1:+17,7:+17,8:−17}. Both price engines reject #7122's invoice at the new claim. The independent raw crossing is + +``` +(0.00364123965018407336305001489908943, + 0.00364123965018407336305001489908944). +``` + +This is a ceiling for this emitted invoice, not other constructions. The retained BIT cap 0.00376669 leaves 0.000125450349816 headroom. The historical nine-stage `complex-local-word-ceiling/ceiling.py` coverage law does not apply to the signed 17-stage caller with these independent helper targets. Selected #7000 remains unchanged. + +The full ordinary source-unit bound is **777,763,024<10⁹**, distinct from physical machine steps. Fresh precision gives height 405, mass exponent 1172 and **c=2344**. Native grid 1125/F24 and caller grid 675 are derived separately and charged together. [APPLICATION.md](APPLICATION.md) supplies every current ownership, physical, precision, ordinary and fixed-tape substitution. + +## Frozen inputs and reproduction + +`INPUTS.json` authenticates the complete nine-file public #7122 export at `98aad9eb0e7d7f985622a35c7981695fe680c68a`, including the complete nested #7121 closure. Its early receipt was native/price-only. During this work, the author published completed revision `6391d64cd0e37e0988e6b9c41fe13f053ed2c81e`; all six construction/source files remained identical (`PEER-STATUS.json`). This package preserves its frozen inputs and independently rebuilds the entire combined application. It does not claim an independent replay of the later peer package. + +Every #7121 and #7122 native byte is reconstructed. Source #7122 SHA256: `880a2402e01a6a92ce8bfde2046fa6375014b16ca4f89d6cc6f5cead621e54f8`. New SHA256: `34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38`. Rohan Arun's #7113 caller remains byte-identical, SHA256: `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`, head `07a76c5e2738882c0cb322278e56f6cae3c9885d`. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-recharted-rank8-split +``` + +Both complete direct 3.14.7 commands passed. Final registered isolated Python 3.12.16 replay passed both commands and matched every frozen native and composition receipt field. The first command checks exact sources/candidate, whole-cut forward/adjoint, complete deltas, fresh grid and separate 18-stage ingredient, four 512-column maps,17 corruption controls and finite native/signed routes. The second rebuilds #7121, #7122 and candidate 17-stage invoices, unchanged rational/integer Laurent caller, owner/phase bindings, all **3,048 paid/helper maps and 104 main boundaries**, fresh envelopes/fixed-tape costs, both prices and 54 strict plus 4 functional outer conditions. A crossing-probe rejection remains active. Every frozen receipt field is compared. + +`VALIDATION.md` records executed checks and the two corrected integration stops. `DISCOVERY.json` records 2,739 systems, 839 states, 183 basis nominations and three legal witnesses. Only index 1 was built; the other two declared groups were unrun under the stop-at-positive rule. The search is not exhaustive rational cost optimization. Discovery code/negative rounds remain local; the public witness and checker do not depend on them. + +## Remaining obligations and credit + +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, maintainer admission and compiled top-level execution remain open. + +Credit **Rohan Arun** for #7122's global rechart and #7113's signed caller/application; **1337isnot1337/OpenAI Codex** for the fresh-helper-boundary alpha-expansion method used by that rechart; **Ali Romman** for helper bases/splits; **Jerry Chen/CubeJerry** for causal/native/invoice/compiler/physical tools; **Matarener** for complete kernels/pairing; **ToikY** for signed predecessors, the chart-120 pattern and later independent chart-259 reproduction; **DreamingOfClouds**, **Douglas Colkitt/#7000 reviewers**, the preceding dillona/OpenAI Codex chain and every retained source notice. This added split was prepared for dillona with substantial OpenAI Codex assistance; no subagents. Apache-2.0. + +## Open next questions + +- Independently reproduce the exact combined construction and inspect the neutral retiming and boundary bases. +- After a fresh canonical/overlap checkpoint, test whether this new helper endpoint or the other recharted groups support another fully charged split. No further gain is established here. + +[Canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521). diff --git a/research/p104-recharted-rank8-split/RECHART.json b/research/p104-recharted-rank8-split/RECHART.json new file mode 100644 index 0000000000..ef91519140 --- /dev/null +++ b/research/p104-recharted-rank8-split/RECHART.json @@ -0,0 +1,151 @@ +{ + "initial": [ + [ + 496, + 595, + 3 + ], + [ + 649, + 597, + 3 + ], + [ + 664, + 105, + 3 + ], + [ + 1310, + 105, + 3 + ], + [ + 1445, + 105, + 3 + ], + [ + 1447, + 597, + 3 + ], + [ + 1449, + 597, + 3 + ] + ], + "scalar": [ + [ + 1189, + 597, + 3 + ], + [ + 1190, + 597, + 3 + ], + [ + 34707, + 105, + 3 + ], + [ + 34708, + 105, + 3 + ], + [ + 34755, + 105, + 3 + ], + [ + 34757, + 105, + 3 + ], + [ + 35071, + 595, + 3 + ], + [ + 35870, + 105, + 3 + ], + [ + 35871, + 105, + 3 + ], + [ + 35872, + 105, + 3 + ], + [ + 35873, + 105, + 3 + ], + [ + 37233, + 597, + 3 + ], + [ + 37234, + 597, + 3 + ], + [ + 37235, + 597, + 3 + ], + [ + 37236, + 597, + 3 + ], + [ + 37237, + 597, + 3 + ], + [ + 37238, + 597, + 3 + ], + [ + 37896, + 595, + 3 + ], + [ + 39038, + 597, + 3 + ], + [ + 39039, + 597, + 3 + ], + [ + 39040, + 597, + 3 + ], + [ + 39072, + 597, + 3 + ] + ] +} \ No newline at end of file diff --git a/research/p104-recharted-rank8-split/REPLAY.txt b/research/p104-recharted-rank8-split/REPLAY.txt new file mode 100644 index 0000000000..478f48eb00 --- /dev/null +++ b/research/p104-recharted-rank8-split/REPLAY.txt @@ -0,0 +1,73 @@ +CHECK Authenticate complete9-file7122export and nested7121closure; reconstruct both sources and combined native, exact arbitrary-input forward/adjoint, causal neutral retiming, complete rechart/target/paid deltas, fresh grid/18-stage ingredient/precision, affected512-column maps,17negativecontrols, finite native/signed routes; compare every receipt 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 73720 public 1491 owned roles 51 paid {1: 4028, 2: 842, 3: 819, 4: 232, 5: 333, 6: 16, 7: 11, 8: 6} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 18, 2: 18, 3: 47, 4: 217, 5: 74, 6: 42, 7: 18, 8: 53, 9: 604} +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 73720 events, 2963 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1091), 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_RECHARTED_RANK8_NATIVE 455081246093/125000000000000 +CHECK Reconstruct retained7121 and peer7122 complete17-stage invoices and candidate invoice; unchanged literal caller, all3048paid/helper maps and104main boundaries, fresh grid/envelopes, ordinary/physical/fixed-tape costs, two prices and54+4outer gates; compare every frozen composition field. +PASS two reconstructed invoices and both exact price engines 0.003641239650184 +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 ['18206198250920366815250074495447/5000000000000000000000000000000000', '7282479300368146726100029798179/2000000000000000000000000000000000'] +RUN check_odd_caller_exact_grid.py +PASS odd caller grid [381, 69, 62] [381, 3, 2] scale bits 10 checked 176874 +RUN check_odd_physical_binding.py +PASS exact physical binding 110655 13600 22291 +RUN check_odd_precision.py +PASS short precision 405 1172 2344 +RUN check_odd_partial_admission.py +ordinary bill 777763024 +PASS partial signed short gates 777763024 455154956273/125000000000000 {'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 42316768 25471767360 precision 2344 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3048 +PASS complete 8+9 component application checks 455154956273/125000000000000 3048 110655 +PASS_P104_RECHARTED_RANK8_SPLIT 455154956273/125000000000000 +PASS_REGISTERED_RESEARCH_PACKAGE research/p104-recharted-rank8-split outcome=partial diff --git a/research/p104-recharted-rank8-split/RESULT.json b/research/p104-recharted-rank8-split/RESULT.json new file mode 100644 index 0000000000..ef3ac9fe3c --- /dev/null +++ b/research/p104-recharted-rank8-split/RESULT.json @@ -0,0 +1,1610 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "46736ff8ebb005d56bd085eb56f77494bb1bc3914a35def3340de864b7985e0f", + "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(\".003641239650184\")", + "old": "claim=Q(\".00363797977\")" + }, + { + "file": "check_odd_partial_admission.py", + "new": "tested=claim+Q(7,10**17)\nwhile tested>=Q(reference[\"raw_bracket\"][0]):\n tested=claim+(tested-claim)/10", + "old": "tested=claim+Q(7,10**17)" + }, + { + "file": "check_odd_partial_admission.py", + "new": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])\ntry:\n gate(invoice,claim,Q(bracket[0]),*bracket,r[\"gate\"][\"BIT_pin\"])\nexcept AssertionError:\n crossing_probe_rejected=True\nelse:\n raise AssertionError(\"Probe at lower crossing unexpectedly accepted\")", + "old": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])" + }, + { + "file": "check_odd_partial_admission.py", + "new": "\"crossing_probe_rejected\":crossing_probe_rejected,\"scope\":\"Reuse exact same native word all-column adjoint;", + "old": "\"scope\":\"Reuse exact same native word all-column adjoint;" + }, + { + "file": "check_odd_precision.py", + "new": "", + "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": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "54d0d837eab62474173c517e7c33c088acaee420893adf6f55d713fef5018114", + "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": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + }, + { + "catalogue_digest": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "4f89979ad1c62005411ec1845c5e0a0df2662e641da6b5c4659b9967ecb7838c", + "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": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + }, + { + "catalogue_digest": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1048, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "34fae455ec7fc7f3e5dbd548aee6ab1554c851637e2793e81e2a428f19d01686", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3048, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "455154956273/125000000000000", + "catalogue": [ + { + "catalogue_digest": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "54d0d837eab62474173c517e7c33c088acaee420893adf6f55d713fef5018114", + "log_sha256": "0ca12d9eebb06dadcb0d1009ab98a60538165409726b4e5be7159ae5bbbc93b1", + "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": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + }, + { + "catalogue_digest": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1000, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "4f89979ad1c62005411ec1845c5e0a0df2662e641da6b5c4659b9967ecb7838c", + "log_sha256": "8ace9bf8e0ef6ad8a2fd7f56119e727cd015d45a10c088fb6654c1ead5bc34f3", + "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": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + }, + { + "catalogue_digest": "3466f64b2c8ac14c447dd20c7ade116c14c9ac905fc8ac264f41afe89825e0ec", + "catalogue_size": 3048, + "checked_maps": 1048, + "distinct_helper_maps": 186, + "distinct_paid_maps": 2963, + "exact_recipe_digest": "34fae455ec7fc7f3e5dbd548aee6ab1554c851637e2793e81e2a428f19d01686", + "log_sha256": "aeb143821cc588321e96c02c508cac1143568262fbe431e211ba7f9449cd9b49", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3048, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b" + } + ], + "fixed_tape_counts": { + "H": 16495300000000000000000, + "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": 2344, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25471767360, + "log_power": 2235, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298740, + "native_invocations": 17, + "native_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58182, + "native": 1146361 + }, + "scalar_services_upper": 42316768, + "scalar_steps_coefficient": 44372347322368, + "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": "455154956273/125000000000000" + }, + "native_archive_sha256": "e8ead5ef5803ec822ccc342a1896c09e3970510f349aa1a6446500739fdc281b", + "native_canonical_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "numeric_gate": { + "BIT_margin": "12545034981593/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16495300000000000000000", + "alpha": [ + 1.0, + 1.0 + ], + "claim": "455154956273/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9023626134898423, + 0.9023626134898423 + ], + "derivative_upper": -382102.2631982782, + "gamma": [ + 0.9407716013413558, + 0.9407716013413558 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364123965018407/100000000000000000": [ + "124236926268721674785871181879037363832940202742519670114979173661952127606661/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6211846313436083739293559093951868191647010137125983505748958683097606380429/5000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455154956273/125000000000000": [ + "24847385253743877644024105922581551760660248633824232352634643262417477547677/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124236926268719388220120529612907758803301243169121161763173216312087387740341/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2234, + "moment_margin_float": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + 1.4298766473147623e-29, + 1.4298766473147623e-29 + ], + "364123965018407/100000000000000000": [ + 1.3053956401873826e-12, + 1.3053956401873826e-12 + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + -2.4517059470688413e-29, + -2.4517059470688413e-29 + ] + }, + "moment_margins": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + "1429876647314762215899925220152749783002638933768829/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "714938323657381107949962610076374891501319486030371/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364123965018407/100000000000000000": [ + "130539564018738247052814714747637833233445041439574198542207407515423/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "130539564018738247052814714747637833233445041439574198542207446137947/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + "-306463243383605184086797127070607989942511860059539/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "-490341189413768294538875403312972783908018968431613/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18206198250920366815250074495447/5000000000000000000000000000000000", + "7282479300368146726100029798179/2000000000000000000000000000000000" + ], + "tested": "364123965018407/100000000000000000", + "written_log_power": 2235 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "319d83fd83ffc77925267704f4f551562510650774c0573eb61c2b452c78f8e2", + "fresh_helpers": 18547, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1491, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "paid_positions": 110655, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22291, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 901, + "9": 10684 + } + }, + "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": 777763024, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222236976, + "odd_divisions": { + "ADD": 5231, + "SCALE": 69 + }, + "per_input_conversion": 2636088, + "raw_upper": 761118776, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2182, + "moves": 6287, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9885000, + "scalar_upper": 1990320 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12545034981593/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16495300000000000000000", + "alpha": [ + 1.0, + 1.0 + ], + "claim": "455154956273/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9023626134898423, + 0.9023626134898423 + ], + "derivative_upper": -382102.2631982782, + "gamma": [ + 0.9407716013413558, + 0.9407716013413558 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364123965018407/100000000000000000": [ + "124236926268721674785871181879037363832940202742519670114979173661952127606661/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6211846313436083739293559093951868191647010137125983505748958683097606380429/5000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455154956273/125000000000000": [ + "24847385253743877644024105922581551760660248633824232352634643262417477547677/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124236926268719388220120529612907758803301243169121161763173216312087387740341/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2234, + "moment_margin_float": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + 1.4298766473147623e-29, + 1.4298766473147623e-29 + ], + "364123965018407/100000000000000000": [ + 1.3053956401873826e-12, + 1.3053956401873826e-12 + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + -2.4517059470688413e-29, + -2.4517059470688413e-29 + ] + }, + "moment_margins": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + "1429876647314762215899925220152749783002638933768829/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "714938323657381107949962610076374891501319486030371/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364123965018407/100000000000000000": [ + "130539564018738247052814714747637833233445041439574198542207407515423/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "130539564018738247052814714747637833233445041439574198542207446137947/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + "-306463243383605184086797127070607989942511860059539/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "-490341189413768294538875403312972783908018968431613/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18206198250920366815250074495447/5000000000000000000000000000000000", + "7282479300368146726100029798179/2000000000000000000000000000000000" + ], + "tested": "364123965018407/100000000000000000", + "written_log_power": 2235 + }, + "crossing_probe_rejected": true, + "finite_rank9_fields": [ + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 3 + }, + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 3 + } + ], + "invoice": { + "P": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 901, + "9": 10684 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036412396501840733630500148990894368374654550363108833992795044821", + "raw_crossing": "0.0036412396501840733630500148990894368374654550363108833992795044821" + }, + "native_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "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": 777763024, + "init_clear_allowance": 216, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 222236976, + "odd_divisions": { + "ADD": 5231, + "SCALE": 69 + }, + "per_input_conversion": 2636088, + "raw_upper": 761118776, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2182, + "moves": 6287, + "owned_lifetime": 216, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9885000, + "scalar_upper": 1990320 + }, + "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": 16495300000000000000000, + "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": 2344, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25471767360, + "log_power": 2235, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298740, + "native_invocations": 17, + "native_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "owned_banks_per_raw_occurrence": 867, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58182, + "native": 1146361 + }, + "scalar_services_upper": 42316768, + "scalar_steps_coefficient": 44372347322368, + "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": "455154956273/125000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "319d83fd83ffc77925267704f4f551562510650774c0573eb61c2b452c78f8e2", + "fresh_helpers": 18547, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1491, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "paid_positions": 110655, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22291, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 867, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 901, + "9": 10684 + } + }, + "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": 2344, + "context_height": 405, + "context_mass_bits": 1172, + "native_grid": { + "coefficient_visits": 15006143, + "dyadic_height": 24, + "mass_witness": [ + 64746, + "stored add" + ], + "maximum_scaled_mass": "1630603680282225/16384", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "precision_program_sha256": "7696f2e4074ccc9c970670494595e2a973742279a6109d1e60fd551a4611d236", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "10033020304601476609715663919666656324072145168222827625345828970418711870546594080057197496826924843217820807496576469018141375099470022439546560159510571884708895840383249301852509812033903477408908035615102368512937596258067967512560191613395685850257141895350326246695640140189729751918611896724340361502949927344742234024268670624305753628203936777184271625627831204851110083533588585441931553958814684505851427652395171/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "strict_power_of_two": 1139, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "258928196220440708948651438400984773603453245337627049737449737451936693642427753722403377239000543811180973005284331268847362205587866920728599788262869611514734271631737711797245816726848092857253612777475282879590661701057445289840736660702666189341757819986489132087938821486044328087484891335884513884444055791321096239617875505598824990545151743202266433829392816990677426071993343881130716863997752163053048274497798241/1896868660409292976994249205822259200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1144, + "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": "4277645777493455922936438172914610813742442481632346068102674073399830905660460577652909551493370392409551905698739430572134554718697165540210997839078313663779775257071828550671429696954174031411777590130400035302462658501791940259390862747191213874087864020053308074770050970827900953337789717155428666185763014265286772390539756196950482094395848301285839232445994335020924516667318574229110447546834246522623040460145100441/210763184489921441888249911758028800000000000000000000000000000000000000000000000", + "strict_power_of_two": 1151, + "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": "258928196220440708948651438400984773603453245337627049737449737451936693642427753722403377239000543811180973005284331268847362205587866920728599788262869611514734271631737711797245816726848092857253612777475282879590661701057445289840736660702666189341757819986489132087938821486044328087484891335884513884444055791321096239617875505598824990545151743202266433829392816990677426071993343881130716863997752163053048274497798241/1896868660409292976994249205822259200000000000000000000000000000000000000000000000", + "strict_power_of_two": 1144, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "3448170914129073567338058808699086038350980741155245174881787508507738497163943700617942832765893615688653504048565613653180648981484058266252144065912298164665945605012326294296218327313271131821330791969016447605045770928893277791895987823449375847901426201712433360089583751366046843451325040440928252759441930984320752000774597193804296985625910432188242375523712154826489688087446572457256718926342348931939041647156904499529228295490019038436705747740928070667156605727620559707675914173289949406827651253834207547226698029542775119040961591719469141/876464560663553576891675682287697443716687967220550563971830539878400000000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1398, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18547, + "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": "10033020304601476609715663919666656324072145168222827625345828970418711870546594080057197496826924843217820807496576469018141375099470022439546560159510571884708895840383249301852509812033903477408908035615102368512937596258067967512560191613395685850257141895350326246695640140189729751918611896724340361502949927344742234024268670624305753628203936777184271625627831204851110083533588585441931553958814684505851427652395171/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "258928196220440708948651438400984773603453245337627049737449737451936693642427753722403377239000543811180973005284331268847362205587866920728599788262869611514734271631737711797245816726848092857253612777475282879590661701057445289840736660702666189341757819986489132087938821486044328087484891335884513884444055791321096239617875505598824990545151743202266433829392816990677426071993343881130716863997752163053048274497798241/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "258928196220440708948651438400984773603453245337627049737449737451936693642427753722403377239000543811180973005284331268847362205587866920728599788262869611514734271631737711797245816726848092857253612777475282879590661701057445289840736660702666189341757819986489132087938821486044328087484891335884513884444055791321096239617875505598824990543254874541857140852398567784855166871993343881130716863997752163053048274497798241/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "10033020304601476609715663919666656324072145168222827625345828970418711870546594080057197496826924843217820807496576469018141375099470022439546560159510571884708895840383249301852509812033903477408908035615102368512937596258067967512560191613395685850257141895350326246695640140189729751918611896724340361502949927344742234024268670624305753628203936777184271625627831204851110083533588585441931553958814684505851427652395171/2529158213879057302658998941096345600000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "258928196220440708948651438400984773603453245337627049737449737451936693642427753722403377239000543811180973005284331268847362205587866920728599788262869611514734271631737711797245816726848092857253612777475282879590661701057445289840736660702666189341757819986489132087938821486044328087484891335884513884444055791321096239617875505598824990545151743202266433829392816990677426071993343881130716863997752163053048274497798241/1896868660409292976994249205822259200000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "119338074512425977664448316637389761955381523581218104222871226802838748612082305952464967717943798979315222612014073853300114655445817781/54147497318342533224087693557760000000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "181321319308778515030581371424850432215716537971911726797777823702021021778313723540251240207598653122393697711120752411788249957672773115044949031221/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "168883501253553195678407371389475493501156904981512573009279842874481548766276250022749238305661709656959956188332428533173313208714652931921498785114429832053/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "34499085382417220472872532967963476859697050580923434657133298239440456570716870677332532695502588455216781456234341667337856491439964061121661524678791547195668658944563/5198159742560883189512418581544960000000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "3303286892297716230205455904258114350867279730697563847366306510346120812390372048365128057125236486756901345694872238280795796468485408466107200771770412602189157692678144726785367/77972396138413247842686278723174400000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "352312410258656384632108170763508791181507050350296568367041978666074310124936479583454779930734711944867813518734114608524640984763006114803286794849836943210123811697853316398500842928115417/8663599570934805315854030969241600000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "102579066128489206475148862685735040715611677697056483755664078358560374605761721245115307512928242942000266279351388659687542169257460640803369386101209852197340622622969733779825854289664641625832145960437343/9746549517301655980335784840396800000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "36582029456407652317823728451738126540405780987192205850799288815171486683391631644710836265035188907818840058084144858077463239154224914493974554529407084332732626804745498116981671671515930190588844617547215083736800194303112644284569395884898557450931653186178814271248840800997832502310967157459711847660999815885454757331939912922214295003/11240703172795810234039995293761536000000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "13910367514578829480984044194329782695210507224710178809892755746474683996717957282477576351599326949230620161359419148412044822281062008973175960356876023374151674584802336728202218022052019669300847989596047846286996777549041924348872093992947905815357554424751700755196930868615268327497743021401946649873779747704034403165467364013352129952646067399725337/281017579319895255850999882344038400000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "6636438878519441123700773980365568561785622325137499078065250106764738425430242889075977689959817855037910358901999005688750617176120114146536562951621743956231780618260129105663009119209128111457726837568800136828521417854472015792129690109007989338615052875742238236027501530740901847002523137058600927215288606437467460996895003667590494217696527098391454199047904803/9367252643996508528366662744801280000000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "83396232099356832308697807373544375235811555411930270038988069370651600764646838558741812138843285116207977270160437512413254278025591958121209150627851841641540208040169189559615901258637510369719215059868893939609515534673418018374767609000100585000340618740837362628546989926642943939898667522334998695074432707453284607914149189508361566754408175080737841429989648902694706899331/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "5493256743615819131266510353485943425519141716988485184888238745960476407913325455636305703913804739541250459584986803691373355967454207496275742414428321166919409472806333176442674347191991894869319713824140431930123556562766853828128585860175111013891589483766227970126504971375204665616905595853437726430152805166406036604260622013332532115104798446337277201929054625316688906821553414339/316144776734882162832374867637043200000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "220617834136950314724077402639719386685004613585637868255144180158266412464383914847402550485702473685957461718555129585843460741246348876526373310711362718908277814077210660747426094619541345769991782302288737630253844486575328586680269919706796965366884536662796890240374556369377515262812927003594840149792361565010865109955856699539885173664549826265325287088411788404647249794789838360790947983291/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "4216484129159932062322532494750885213771638486884988950660010548124107266582741695695306753750618838172147391922471146177151602646433964970234498389986856241376145858202206824577705322171909501480463126839858009739328323765286399653655331731553260370704731925214645398726775717096578882117761306767760570681712520625524377979311667389116979186082437465885631077325602640350807115438126495115592028047475150761/1264579106939528651329499470548172800000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "4667607605480028129344622554857881558185069978548343003305976774960091320670937582692503132182825263715864589277859202219150506396426021192923981038116573845945831557808218181686181195117918273923800187805286175146411075241014323564094028364789320804863664870239496892567391162083133811142339840583526541859441180180892584800786242408000710891042749985071543943239154475836417899052091683316484117005521280242816062163/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "10033020304601476609715663919666656324072145168222827625345828970418711870546594080057197496826924843217820807496576469018141375099470022439546560159510571884708895840383249301852509812033903477408908035615102368512937596258067967512560191613395685850257141895350326246695640140189729751918611896724340361502949927344742234024268670624305753628203936777184271625627831204851110083533588585441931553958814684505851427652395171/2529158213879057302658998941096345600000000000000000000000000000000000000000000000", + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "event": 4691, + "stage": 17 + } + ], + "physical_main_inputs": 3744, + "sites": { + "ADD": 4126, + "IDLE_ODD": 4, + "IDLE_ONE": 90, + "J": 17, + "LAMBDA": 178, + "QUERY": 4, + "SCALE": 312, + "SWAP": 52, + "noninteger_scalar": 1752 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 258, + "witness": { + "cut": 73720, + "factor": "1", + "kind": "public-return", + "register": 1483 + } + }, + "M": { + "exact": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "strict_power_of_two": 260, + "witness": { + "cut": 72970, + "factor": "1", + "kind": "stored", + "register": 1483 + } + }, + "Sigma": { + "exact": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000", + "strict_power_of_two": 258, + "witness": { + "cut": 72970, + "factor": "1", + "kind": "stored", + "register": 1483 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 73720, + "lifetimes": 54, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 63624, + "CLEAR": 54, + "COPY": 1, + "INIT": 54, + "MOVE": 6287, + "SCALE": 3700 + }, + "owned_labels": 51, + "peak_owned": 43, + "public": 1491, + "scalars": { + "dyadic": 62025, + "integer": 39299, + "noninteger": 28026, + "odd": 5300 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + }, + "M": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26076, + "entrance_mass": "343682242180615120331145367931209730590196726666925870609225437552229252474463121253894411655859031242717191366590407398910330172071/346543982837392212634161238769664000000000000000000000", + "residual_mass": "69568373285422047166910428042668452417054100619397090149959296425185829725464445565633125913820162263843525449785569170057085377083/173271991418696106317080619384832000000000000000000000" + } + } + }, + "scope": "Fixed integer Laurent grid with charged odd caller scale, and pinned attributed forward/adjoint all-fibre defect engine applied to the emitted 17-stage caller. Each LAMBDA, QUERY and signed/unsigned idle is one unitary with one child defect. The caller allocation assumes independent stage helpers. Full physical application remains separate." + }, + "ODD-TYPE-AB-REPLAY.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "paid": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "raw_bracket": [ + "18206198250920366815250074495447/5000000000000000000000000000000000", + "7282479300368146726100029798179/2000000000000000000000000000000000" + ], + "replay": { + "bad_outputs": [], + "caller_denominator_height_bound": 578, + "caller_mass_bound": "854474036861847560509026474008040300059938928517783661039773198072080884690114508581583887358835968277340425788985297793555303569703690223623950838857161290503004459697662544865276977234864184443860251086668962688762176068520364648820282528496698239206689277049335412289161443623602012468587331439851515703/168151253906250000000000000000000", + "caller_mass_ceiling_bits": 910, + "max_terms": 3752 + }, + "scope": "Exact emitted signed Laurent caller endpoint and recomputed native/caller paid and target profiles. Physical address bindings, independent branch-source composition, ordinary units, precision and outer gates are still required.", + "shape": [ + 8, + 9 + ], + "source_word_sha256": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "target": { + "1": 306, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 901, + "9": 10684 + } + } + }, + "claim": "455154956273/125000000000000", + "price": { + "after": { + "P": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 901, + "9": 10684 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036412396501840733630500148990894368374654550363108833992795044821", + "raw_crossing": "0.0036412396501840733630500148990894368374654550363108833992795044821" + }, + "before": { + "P": { + "1": 68860, + "16": 416, + "2": 14314, + "24": 416, + "3": 13923, + "32": 416, + "4": 3944, + "40": 416, + "48": 416, + "5": 5661, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 289, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3689, + "41": 416, + "49": 416, + "5": 1258, + "57": 416, + "6": 714, + "65": 416, + "7": 289, + "73": 208, + "8": 918, + "9": 10684 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036407613741422058608084968767767908867943890369857566819992927556", + "raw_crossing": "0.0036407613741422058608084968767767908867943890369857566819992927556" + }, + "gate": { + "BIT_margin": "12545034981593/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16495300000000000000000", + "alpha": [ + 1.0, + 1.0 + ], + "claim": "455154956273/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9023626134898423, + 0.9023626134898423 + ], + "derivative_upper": -382102.2631982782, + "gamma": [ + 0.9407716013413558, + 0.9407716013413558 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364123965018407/100000000000000000": [ + "124236926268721674785871181879037363832940202742519670114979173661952127606661/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6211846313436083739293559093951868191647010137125983505748958683097606380429/5000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455154956273/125000000000000": [ + "24847385253743877644024105922581551760660248633824232352634643262417477547677/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124236926268719388220120529612907758803301243169121161763173216312087387740341/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2234, + "moment_margin_float": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + 1.4298766473147623e-29, + 1.4298766473147623e-29 + ], + "364123965018407/100000000000000000": [ + 1.3053956401873826e-12, + 1.3053956401873826e-12 + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + -2.4517059470688413e-29, + -2.4517059470688413e-29 + ] + }, + "moment_margins": { + "18206198250920366815250074495447/5000000000000000000000000000000000": [ + "1429876647314762215899925220152749783002638933768829/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "714938323657381107949962610076374891501319486030371/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364123965018407/100000000000000000": [ + "130539564018738247052814714747637833233445041439574198542207407515423/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "130539564018738247052814714747637833233445041439574198542207446137947/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "7282479300368146726100029798179/2000000000000000000000000000000000": [ + "-306463243383605184086797127070607989942511860059539/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "-490341189413768294538875403312972783908018968431613/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18206198250920366815250074495447/5000000000000000000000000000000000", + "7282479300368146726100029798179/2000000000000000000000000000000000" + ], + "tested": "364123965018407/100000000000000000", + "written_log_power": 2235 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "34cc0c51ca9eaaf2bf3789b8ea2c92f0837b4be9f0fedb22a6150169038e8c38", + "old_native": "880a2402e01a6a92ce8bfde2046fa6375014b16ca4f89d6cc6f5cead621e54f8", + "peer_derived_crossings": { + "no_E_credit_crossing": "0.0036407613741422058608084968767767908867943890369857566819992927556", + "raw_crossing": "0.0036407613741422058608084968767767908867943890369857566819992927556" + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "18564697829495983819126913027781847134519062406384430737504863700480838269892919/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "371293956589919676382538260555636942690381248127688614750097274009616766085247/2000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003641239650184", + "gain": "4.78276042E-7", + "gain_exact": "239138021/500000000000000", + "independent_raw_bracket": [ + "0.00364123965018407336305001489908943", + "0.00364123965018407336305001489908944" + ], + "previous_claim": "1820380687071/500000000000000", + "raw_bracket": [ + "0.0036412396501840733630500148990894", + "0.0036412396501840733630500148990895" + ] + }, + "retained_before": { + "P": { + "1": 68962, + "16": 416, + "2": 14297, + "24": 416, + "3": 13906, + "32": 416, + "4": 4080, + "40": 416, + "48": 416, + "5": 5525, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "S": 1424, + "T": { + "1": 289, + "137": 208, + "17": 416, + "2": 306, + "25": 416, + "3": 799, + "33": 416, + "4": 3723, + "41": 416, + "49": 416, + "5": 1224, + "57": 416, + "6": 714, + "65": 416, + "7": 306, + "73": 208, + "8": 969, + "9": 10616 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036401021873964907241085191294166921194597121219375525703542844145", + "raw_crossing": "0.0036401021873964907241085191294166921194597121219375525703542844145" + }, + "retained_native": "0a27f1224fdb196602d52d4170bc12b8bde0b9818809e73ecdbdaaa5d3b7adbc" + }, + "status": "PASS_P104_RECHARTED_RANK8_SPLIT" +} diff --git a/research/p104-recharted-rank8-split/SOURCES.json b/research/p104-recharted-rank8-split/SOURCES.json new file mode 100644 index 0000000000..c4150ae397 --- /dev/null +++ b/research/p104-recharted-rank8-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-recharted-rank8-split/TASK.json b/research/p104-recharted-rank8-split/TASK.json new file mode 100644 index 0000000000..b4f7fc492b --- /dev/null +++ b/research/p104-recharted-rank8-split/TASK.json @@ -0,0 +1,144 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "author": "Prepared for dillona with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19520521", + "scope_status": "changed", + "scope_change_reason": "Rohan Arun7122 moves7helper inputs, including1445 into3\u2192246. That changed boundary group enables a new common basis and rank8\u21927+1 split; this is separate from peer frame optimization and pending application verification.", + "concrete_question": "Can an additional helper split improve the exact recharted7122 word after all application costs?", + "actual_scope": "Exact7122 cut40552/chart924/pivot454; neutral advance of454from757to924, helper8\u21927+1,22ADD+4SCALE and no paid-profile change relative7122. Reconstruct the entire credited rechart from7121.", + "domain": "Declared3\u2192246,3\u2192120,3\u2192127 in order; first group produced3nominations. Only index1 built; other2groups unrun under stop-at-positive rule.", + "success": "A complete arbitrary-input native and signed17-stage application with\u03ba>.003640761374142.", + "bottleneck_link": "New input frame of1445 permits a boundary basis with454/1208/1461; the fresh helper, scalar bases, envelopes and every downstream cost remain charged.", + "predecessor_head": "98aad9eb0e7d7f985622a35c7981695fe680c68a", + "predecessors": [ + "Rohan Arun7122 global input rechart, exact98aad9eb0e7d7f985622a35c7981695fe680c68a, retained as complete9-fileexport with nested7121closure; draft native/price evidence at this frozen head.", + "1337isnot1337/OpenAI Codex fresh-helper-boundary/discover-cut.cpp alpha-expansion method used by Rohan Arun7122; later completed source6391d64 retains identical six construction/source files, recorded in PEER-STATUS.json.", + "ToikY Discussion7111 original chart120 pattern, retained through7120; it is distinct from this chart259 changed-group split.", + "Ali Romman: helper bases, independent split identity and paid meetings", + "Jerry Chen/CubeJerry: causal retiming, native/invoice/compiler engines", + "Matarener: complete kernels including zero boundary images and pairing decision", + "Rohan Arun: exact7113 signed17-stage caller and source-specific application", + "ToikY: #7108\u2013#7110 signed sources and splits, plus the credited chart-120 lead in Discussion #7111", + "DreamingOfClouds, Douglas Colkitt/#7000 reviewers and all retained nested-source notices", + "dillona/OpenAI Codex:7105,7107,7112,7115,7116,7117; exact7117 parent retains all earlier exports", + "dillona/OpenAI Codex7118: first funded residual mode and exact source-specific application", + "dillona/OpenAI Codex7119: exact reciprocal source and full application", + "ToikY original chart120 pattern and dillona/OpenAI Codex7120 exact-source composition, fully retained as the immediate source." + ], + "outcome": "completed", + "evidence_status": "Both complete direct CPython3.14.7 commands and final isolated registered CPython3.12.16 replay passed; every frozen native/composition receipt field matched, including17nativecontrols,3048paid/helper maps,104main boundaries and54+4outer conditions.", + "evidence": "WITNESS.json,WORD.json.gz,INPUTS.json,NATIVE-RESULT.json,RESULT.json,REPLAY.txt when complete.", + "overlap": "Canonicale545/priority8/selected7000 unchanged.422openPRs20:45:23UTC/7022Discussionrecords20:46:35UTC completepagination. Live7122head and updatedToikY7111 read; public claim separates added helper split from peer frame optimization/full application work. Final canonical/live checkpoint21:09UTC unchanged; source7122 completed revision6391d64 retains exact construction/source files and ToikY7111 has distinct paid-MOVE/caller scopes.", + "open_questions": [ + { + "question": "Does an independent reviewer reproduce this newly available helper split and complete application?", + "why_it_matters": "A changed helper group permits a new basis but does not alone establish legal physical endpoints or the conditional claim.", + "first_step": "Replay registered3.12 commands against the exact7122 export and inspect the neutral454advance plus concrete boundary/cut bases.", + "blocked_by": "Independent human/formal review and maintainer admission remain separate." + }, + { + "question": "Can subsequent changed helper endpoints support another fully priced legal construction?", + "why_it_matters": "This result is one exact word, not a fixed-model or global optimum.", + "first_step": "Refresh canonical main and overlap, pin the emitted word, and name a changed source-specific contract before searching.", + "blocked_by": "No gain is established beyond this emitted instance." + } + ], + "stop_rule": "One new fully checked invoice; refresh before any further research round." +} diff --git a/research/p104-recharted-rank8-split/VALIDATION.md b/research/p104-recharted-rank8-split/VALIDATION.md new file mode 100644 index 0000000000..2e22c5977b --- /dev/null +++ b/research/p104-recharted-rank8-split/VALIDATION.md @@ -0,0 +1,18 @@ +# Validation record + +Both complete direct CPython3.14.7 commands passed: + +```sh +python3 -I -B research/p104-recharted-rank8-split/verify_native.py --out research/p104-recharted-rank8-split/NATIVE-RESULT.json +python3 -I -B research/p104-recharted-rank8-split/verify.py --out research/p104-recharted-rank8-split/RESULT.json +``` + +The native command covers every exact source/candidate byte, whole-cut and full forward/adjoint identities, complete rechart/target/paid deltas, derived1125/F24grid, separate18-stage ingredient invoice and precision, four512-column chart maps,17negativecontrols, and complete finite native/signed routes. The application covers7121/7122/candidate invoices, unchanged rational/integer Laurent caller, all3048paid/helper maps and104main boundaries, owner/phase bindings, fresh grids/envelopes/ordinary/fixed-tape costs, both prices and54strict+4functional outer conditions. The crossing-probe rejection remains active. + +The first native attempt stopped before scientific checks because extraction exhausted local disk space. A sparse checkout of only this isolated worktree freed space; no tracked source, frozen archive or retained evidence changed. The full subsequent native command passed. The first composition attempt detected that7122's early invoice deliberately omitted the two derived decimal crossing display fields. The adapter now compares every published invoice field, recomputes both displays, requires their equality and checks their value strictly inside the peer's directed bracket. No cost or inequality was relaxed. The complete subsequent composition passed. + +Final registered isolated CPython 3.12.16 replay passed both complete commands and matched every frozen native and composition receipt field. REPLAY.txt preserves the actual stdout; the process exited successfully. Metadata was marked completed afterwards, explaining outcome=partial in the captured runner line. No scientific code or receipt changed after this comparison. No hosted scientific pass is claimed. The known canonical guide6030/selected7000 onboarding mismatch is separate; the source author's later7122 revision carries a correction, while this package-only contribution preserves canonical guidance. + +Discovery stopped after the first declared group produced three smooth nominations. Only index1 was constructed; indices0/2 and groups3→120/3→127 were not built/run. Complete kernels do not make the cost/alphabet nomination an exhaustive rational optimizer. The public finite witness is independently replayable without the local search code. + +Five assumptions, independent human/formal review, maintainer admission and compiled top-level execution remain. No Lean or Docker was run. diff --git a/research/p104-recharted-rank8-split/VERIFY.json b/research/p104-recharted-rank8-split/VERIFY.json new file mode 100644 index 0000000000..37acae64a2 --- /dev/null +++ b/research/p104-recharted-rank8-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 complete9-file7122export and nested7121closure; reconstruct both sources and combined native, exact arbitrary-input forward/adjoint, causal neutral retiming, complete rechart/target/paid deltas, fresh grid/18-stage ingredient/precision, affected512-column maps,17negativecontrols, finite native/signed routes; compare every receipt field." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Reconstruct retained7121 and peer7122 complete17-stage invoices and candidate invoice; unchanged literal caller, all3048paid/helper maps and104main boundaries, fresh grid/envelopes, ordinary/physical/fixed-tape costs, two prices and54+4outer gates; compare every frozen composition field." + } + ] +} diff --git a/research/p104-recharted-rank8-split/WITNESS.json b/research/p104-recharted-rank8-split/WITNESS.json new file mode 100644 index 0000000000..1cf780ec0c --- /dev/null +++ b/research/p104-recharted-rank8-split/WITNESS.json @@ -0,0 +1,56 @@ +{ + "frame": 924, + "pivot": 454, + "cut": 40552, + "ranks": [ + 7, + 1 + ], + "gain": 0.010918442909852999, + "paths": [ + { + "role": 454, + "lo": 40015, + "hi": 42239, + "frame": 924, + "old": 757, + "new": 924, + "moves": [ + 42238 + ], + "old_paid": [ + 1 + ], + "new_paid": [ + 1, + 0 + ], + "cost": 0.0, + "private": false, + "neutral": true + } + ], + "a": { + "1461": "1", + "1208": "-1/4" + }, + "b": { + "454": "1/3", + "207": "-1/3", + "1208": "4/3", + "1461": "4/3" + }, + "c": { + "1461": "1", + "1208": "-1/4", + "454": "1", + "1445": "-1/2" + }, + "d": { + "454": "1/3", + "1445": "2/3", + "1208": "4/3", + "1461": "4/3" + }, + "paid_delta": {} +} diff --git a/research/p104-recharted-rank8-split/WORD.json.gz b/research/p104-recharted-rank8-split/WORD.json.gz new file mode 100644 index 0000000000..e517ac8b91 Binary files /dev/null and b/research/p104-recharted-rank8-split/WORD.json.gz differ diff --git a/research/p104-recharted-rank8-split/adapt.py b/research/p104-recharted-rank8-split/adapt.py new file mode 100644 index 0000000000..d9f219e796 --- /dev/null +++ b/research/p104-recharted-rank8-split/adapt.py @@ -0,0 +1,38 @@ +"""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(".003641239650184")') + # ToikY's frozen exact_price() already shrinks this probe below the + # certified crossing. Recompute that rule in the caller's separate gate. + patch('check_odd_partial_admission.py', + 'tested=claim+Q(7,10**17)', + 'tested=claim+Q(7,10**17)\nwhile tested>=Q(reference["raw_bracket"][0]):\n tested=claim+(tested-claim)/10') + patch('check_odd_partial_admission.py', + 'g=gate(invoice,claim,tested,*bracket,r["gate"]["BIT_pin"])', + 'g=gate(invoice,claim,tested,*bracket,r["gate"]["BIT_pin"])\ntry:\n gate(invoice,claim,Q(bracket[0]),*bracket,r["gate"]["BIT_pin"])\nexcept AssertionError:\n crossing_probe_rejected=True\nelse:\n raise AssertionError("Probe at lower crossing unexpectedly accepted")') + patch('check_odd_partial_admission.py', + '"scope":"Reuse exact same native word all-column adjoint;', + '"crossing_probe_rejected":crossing_probe_rejected,"scope":"Reuse exact same native word all-column adjoint;') + patch('check_odd_precision.py','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-recharted-rank8-split/construct.py b/research/p104-recharted-rank8-split/construct.py new file mode 100644 index 0000000000..258dc16d49 --- /dev/null +++ b/research/p104-recharted-rank8-split/construct.py @@ -0,0 +1,18 @@ +"""Compose Rohan Arun's #7122 rechart with one charged, causal helper split. +Ali Romman and CubeJerry supply the retained split and retiming mechanisms. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +import json +from rechart import construct as rechart +from retime import prepare as retime +from split import split +HERE=Path(__file__).resolve().parent + +def prepare(word,hit): + changed=rechart(word,json.loads((HERE/'RECHART.json').read_text())) + return retime(changed,hit) + +def construct(word,hit): + prepared,spec=prepare(word,hit) + return split(prepared,spec) diff --git a/research/p104-recharted-rank8-split/derive_grid.py b/research/p104-recharted-rank8-split/derive_grid.py new file mode 100644 index 0000000000..f8cb37f00b --- /dev/null +++ b/research/p104-recharted-rank8-split/derive_grid.py @@ -0,0 +1,36 @@ +"""Derive a finite common grid from every exact prefix row and scalar product. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction as Q +from math import lcm +from pathlib import Path +import gzip,json,sys + +def derive(word): + n=word['public'];rows=[{r:Q(1)}for r in range(n)]+[{}for _ in range(word['owned_fields'])] + denom=1;peak=Q(1);witness=None;visits=0 + def observe(row,i,kind): + nonlocal denom,peak,witness,visits + for v in row.values():denom=lcm(denom,v.denominator);visits+=1 + mass=sum(map(abs,row.values())) + if mass>peak:peak=mass;witness=[i,kind] + for i,e in enumerate(word['program']): + op,r=e[:2] + if op in('INIT','CLEAR'):rows[r]={} + elif op=='SCALE': + rows[r]={k:Q(e[2])*v for k,v in rows[r].items()};observe(rows[r],i,'scale') + elif op in('ADD','COPY'): + if op=='COPY':assert not rows[r] + product={k:Q(e[3])*v for k,v in rows[e[2]].items()};observe(product,i,'product') + row=rows[r].copy() + for k,v in product.items(): + value=row.get(k,Q(0))+v + if value:row[k]=value + else:row.pop(k,None) + rows[r]=row;observe(row,i,'stored') + odd=denom;frac=0 + while odd%2==0:odd//=2;frac+=1 + return dict(odd_scale=odd,fractional_bits=frac,unscaled_maximum_mass=str(peak),scaled_maximum_mass=str(peak*odd),mass_witness=witness,coefficient_visits=visits),rows +if __name__=='__main__': + w=json.load(gzip.open(sys.argv[1],'rt'));result,rows=derive(w) + Path(sys.argv[2]).write_text(json.dumps(result,indent=2)+'\n');print(result) diff --git a/research/p104-recharted-rank8-split/inputs/pr7122.tar b/research/p104-recharted-rank8-split/inputs/pr7122.tar new file mode 100644 index 0000000000..c2f750a510 Binary files /dev/null and b/research/p104-recharted-rank8-split/inputs/pr7122.tar differ diff --git a/research/p104-recharted-rank8-split/price.py b/research/p104-recharted-rank8-split/price.py new file mode 100644 index 0000000000..1362977c0e --- /dev/null +++ b/research/p104-recharted-rank8-split/price.py @@ -0,0 +1,68 @@ +"""Recompute both source invoices and two exact crossing engines. +Retains Rohan Arun's caller adapters and ToikY's attributed price engines. +Prepared for dillona with substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +from hashlib import sha256 +from fractions import Fraction as Q +import gzip,importlib.util,json,sys + +def load(name,path): + spec=importlib.util.spec_from_file_location(name,path);obj=importlib.util.module_from_spec(spec);sys.modules[name]=obj;spec.loader.exec_module(obj);return obj + +def read(path): + raw=Path(path).read_bytes();return json.loads(gzip.decompress(raw) if raw[:2]==b'\x1f\x8b' else raw) + +def normalized(value):return json.loads(json.dumps(value,default=str)) + +def main(native,caller,previous_composition,folder): + source=load('composition_native_source',native/'source.py') + with source.sources() as (vendor,archive,rank9,bundle,parent,word): + sys.path.insert(0,str(folder)) + model=load('composition_signed_model',folder/'signed_model.py');ind=model.signed_model() + code=(folder/'independent.py').read_text();part=code[code.index('def invoices('):code.index('def ordinary(')] + assert part.count('assert calls==18')==1 + part=part.replace('assert calls==18',"assert calls==C['stages']") + old="elif e[1]=='IDLE_ONE':P[8*len(e[3])]+=ports";assert part.count(old)==1 + part=part.replace(old,"elif e[1] in ('IDLE_ONE','IDLE_ODD'):P[8*len(e[3])+(e[1]=='IDLE_ODD')]+=ports") + exec(compile(part,str(folder/'independent.py'),'exec'),ind.__dict__) + C=read(caller/'expected/ODD-TYPE-AB-CALLER.json') + old_word=word;new_word=read(native/'WORD.json.gz') + old_result=read(parent/'NATIVE-RESULT.json');new_result=read(native/'NATIVE-RESULT.json') + inventories=[ind.native(w) for w in (old_word,new_word)] + for n,r,w in zip(inventories,(old_result,new_result),(old_word,new_word)): + assert normalized(n)==r['native'] and not n['bad_inputs'] + assert sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest()==r['word_canonical_sha256'] + before,after=[ind.invoices(w,C,n) for w,n in zip((old_word,new_word),inventories)] + previous=read(previous_composition/'RESULT.json')['price'] + assert normalized(before)==previous['after'],'Entire reconstructed current #7121 invoice' + G=load('composition_price_engine',bundle/'gate.py') + peer=read(native/'PEER-EARLY.json') + rechart=load('composition_rechart',native/'rechart.py') + peer_word=rechart.construct(old_word,read(native/'RECHART.json')) + peer_inventory=ind.native(peer_word) + assert normalized(peer_inventory)==peer['native'] and not peer_inventory['bad_inputs'] + peer_invoice=ind.invoices(peer_word,C,peer_inventory) + # The public early receipt deliberately omitted the two derived decimal + # crossing display fields; compare every other field and bracket those too. + peer_core=dict(peer_invoice) + peer_crossings={k:peer_core.pop(k) for k in ('raw_crossing','no_E_credit_crossing')} + assert normalized(peer_core)==peer['invoice'],'Every published #7122 invoice field' + assert peer_crossings['raw_crossing']==peer_crossings['no_E_credit_crossing'] + assert Q(peer['gate']['raw_bracket'][0])Q(peer['gate']['claim'])>Q(previous['gate']['claim']) + 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(peer_derived_crossings=peer_crossings,retained_before=retained_before,before=before,after=after,gate=gate,price=price,native_baseline_rejects_new_claim=True, + retained_native=old_result['word_canonical_sha256'],old_native=peer['word_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-recharted-rank8-split/rechart.py b/research/p104-recharted-rank8-split/rechart.py new file mode 100644 index 0000000000..abab5b5b7c --- /dev/null +++ b/research/p104-recharted-rank8-split/rechart.py @@ -0,0 +1,39 @@ +"""Rechart public scalar contacts and reconstruct every causal transport. + +Fresh-helper-boundary alpha-expansion supplied the nomination. This generator +does not trust its floating score. Rohan Arun/OpenAI Codex, Apache-2.0. +""" +from copy import deepcopy +def span(basis): + out={0} + for x in basis: + assert x not in out;out|={x^v for v in tuple(out)} + return frozenset(out) +def construct(source,changes): + w=deepcopy(source);n=w['public'];spaces=list(map(span,w['frames'])) + main=set(w['live'])|{r+112 for r in w['live']}|set(w['hosted']['X2'])|set(w['hosted']['Y2']) + for r,old,new in changes['initial']: + assert r=n and spaces[to]=n]);cur[r]=to + for i,e in enumerate(source['program']): + op,r=e[:2] + if op=='MOVE': + if r>=n:assert cur[r]==e[2];move(r,e[3]) + elif op=='INIT':assert r>=n and cur[r] is None;program.append(e.copy());cur[r]=e[2] + elif op=='CLEAR':assert r>=n and cur[r]==e[2];program.append(e.copy());cur[r]=None + else: + assert op in ('ADD','COPY','SCALE');roles=e[1:3] if op in ('ADD','COPY') else e[1:2];frame=e[-1] + if i in edits: + old,frame=edits[i];assert old==e[-1] and all(r= 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-recharted-rank8-split/support.py b/research/p104-recharted-rank8-split/support.py new file mode 100644 index 0000000000..192cd38d27 --- /dev/null +++ b/research/p104-recharted-rank8-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']['1461']='2' + controls['wrong_prefix']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['b']['207']='-1/2' + controls['wrong_suffix']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['frame']=734 + controls['wrong_cut_frame']=rejected(lambda:construct(source,bad)) + from split import basis + Gbasis=basis(*[{int(k):Q(v)for k,v in hit[s].items()}for s in('c','d')],hit['pivot'],3) + Jbasis=basis(*[{int(k):Q(v)for k,v in hit[s].items()}for s in('a','b')],hit['pivot'],924) + need((len(Gbasis),len(Jbasis))==(7,6),'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']) + bad=deepcopy(hit);bad['c']['1445']='-1' + controls['wrong_boundary_functional']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['d']['1445']='1/3' + controls['wrong_boundary_direction']=rejected(lambda:construct(source,bad)) + for name,index in [('missing_initial_basis',0),('missing_final_basis',len(word['program'])-1)]: + bad=deepcopy(word);bad['program'].pop(index) + controls[name]=bool(I.native(bad)['bad_inputs']) + bad=deepcopy(word);bad['initial'][-1]=3 + controls['wrong_successor_frame']=rejected(lambda:I.native(bad)) + bad=deepcopy(hit);bad['ranks']=[4,4] + controls['wrong_target_ranks']=rejected(lambda:construct(source,bad)) + bad=deepcopy(hit);bad['paths'][0]['hi']=bad['paths'][0]['moves'][0] + controls['incomplete_retiming_interval']=rejected(lambda:prepare(source,bad)) + bad=deepcopy(hit);bad['paid_delta']={'1':1} + controls['wrong_paid_declaration']=rejected(lambda:prepare(source,bad)) + from rechart import construct as rechart + changes=read(HERE/'RECHART.json') + bad=deepcopy(changes);bad['initial']=[row for row in bad['initial'] if row[0]!=1445] + controls['missing_peer_input_rechart']=rejected(lambda:rechart(source,bad)) + bad=deepcopy(changes);bad['scalar'].pop(0) + controls['missing_peer_contact_rechart']=rejected(lambda:rechart(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_RECHARTED_RANK8_NATIVE',source_head='98aad9eb0e7d7f985622a35c7981695fe680c68a', + 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()