diff --git a/research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json b/research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json new file mode 100644 index 0000000000..13b3d3af9a --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json @@ -0,0 +1,14 @@ +[ + [ + "8 <= owned <= 22", + "8 <= owned <= 25" + ], + [ + "public == 767", + "767 <= public <= 770" + ], + [ + "0 < peak <= 12", + "0 < peak <= 13" + ] +] diff --git a/research/p104-asynchronous-helper-hubs/NOTICE b/research/p104-asynchronous-helper-hubs/NOTICE new file mode 100644 index 0000000000..f3c2f7136c --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/NOTICE @@ -0,0 +1,67 @@ +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. diff --git a/research/p104-asynchronous-helper-hubs/PLAN.json b/research/p104-asynchronous-helper-hubs/PLAN.json new file mode 100644 index 0000000000..9cf72d400f --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/PLAN.json @@ -0,0 +1,193 @@ +{ + "source_canonical_sha256": "75f429fc0c8b206f4439bfbda4b621fc62ea892e6e3008c17409f2d3ee0981bb", + "steps": [ + { + "pivot": 696, + "frame": 1031, + "time2": 27044, + "buffer": 790, + "collection": [ + { + "time2": 27026, + "role": 696, + "coefficient": "1" + } + ], + "injection": [ + { + "time2": 27044, + "role": 696, + "coefficient": "1" + }, + { + "time2": 27044, + "role": 697, + "coefficient": "1" + }, + { + "time2": 27501, + "role": 770, + "coefficient": "1" + }, + { + "time2": 27516, + "role": 699, + "coefficient": "1" + } + ], + "input": { + "696": "1" + }, + "output": { + "733": "1", + "709": "1", + "696": "1", + "133": "2", + "699": "1", + "697": "1" + }, + "queries": [ + 13750 + ], + "source_sha256": "75f429fc0c8b206f4439bfbda4b621fc62ea892e6e3008c17409f2d3ee0981bb", + "query_events": [ + [ + "MOVE", + 770, + 591, + 597, + true + ] + ], + "output_sha256": "42b7418cdcd42c50a09ec8bd97cd42f4953802e16f179997643d8bde503735f1" + }, + { + "pivot": 623, + "frame": 117, + "time2": 26314, + "buffer": 792, + "collection": [ + { + "time2": 26314, + "role": 623, + "coefficient": "1" + } + ], + "injection": [ + { + "time2": 26318, + "role": 624, + "coefficient": "1" + }, + { + "time2": 26330, + "role": 627, + "coefficient": "-1/2" + }, + { + "time2": 26332, + "role": 629, + "coefficient": "-1/2" + }, + { + "time2": 26336, + "role": 629, + "coefficient": "1/2" + }, + { + "time2": 32701, + "role": 732, + "coefficient": "1/2" + } + ], + "input": { + "623": "1" + }, + "output": { + "732": "1/2", + "576": "2", + "549": "2", + "570": "4", + "558": "-4", + "575": "2", + "548": "2", + "569": "2", + "547": "2", + "546": "-2", + "568": "4", + "205": "1", + "625": "-1", + "623": "1", + "627": "-1/2", + "624": "1" + }, + "queries": [ + 16350 + ], + "source_sha256": "42b7418cdcd42c50a09ec8bd97cd42f4953802e16f179997643d8bde503735f1", + "query_events": [ + [ + "MOVE", + 732, + 594, + 222, + false + ] + ], + "output_sha256": "21b8911d58e6d7777dc7458ccf5b05f1da8669bc1044270909746ddd4abc5948" + }, + { + "pivot": 585, + "frame": 245, + "time2": 34391, + "buffer": 794, + "collection": [ + { + "time2": 31557, + "role": 438, + "coefficient": "-1" + }, + { + "time2": 34391, + "role": 585, + "coefficient": "1" + } + ], + "injection": [ + { + "time2": 34391, + "role": 585, + "coefficient": "1" + } + ], + "input": { + "585": "1" + }, + "output": { + "585": "1" + }, + "queries": [ + 15778, + 17195 + ], + "source_sha256": "21b8911d58e6d7777dc7458ccf5b05f1da8669bc1044270909746ddd4abc5948", + "query_events": [ + [ + "MOVE", + 438, + 911, + 127, + false + ], + [ + "MOVE", + 585, + 918, + 127, + false + ] + ], + "output_sha256": "45e3f8efd004f2a6d2c02a2ac2ebe3dd9ce04c887641ec9ab31e47f8c7f41e1b" + } + ] +} diff --git a/research/p104-asynchronous-helper-hubs/PRICING-EDITS.json b/research/p104-asynchronous-helper-hubs/PRICING-EDITS.json new file mode 100644 index 0000000000..11cc4d00e2 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/PRICING-EDITS.json @@ -0,0 +1,18 @@ +[ + [ + "KAPPA, TESTED = Q('.00312192127'), Q('.003121921275')", + "KAPPA, TESTED = Q('.00312265044'), Q('.003122650445')" + ], + [ + "PREVIOUS = Q('.00311301600')", + "PREVIOUS = Q('.00312192127')" + ], + [ + "sum(targets.values()) == 13390 and sum(paid.values()) == 66834", + "sum(targets.values()) == 13444 and sum(paid.values()) == 66906" + ], + [ + "'kappa_decimal':'0.00312192127','previous_pr5751':PREVIOUS", + "'kappa_decimal':'0.00312265044','previous_pr5774':PREVIOUS" + ] +] diff --git a/research/p104-asynchronous-helper-hubs/PROOF.md b/research/p104-asynchronous-helper-hubs/PROOF.md new file mode 100644 index 0000000000..e4cf2e4d06 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/PROOF.md @@ -0,0 +1,189 @@ +# Temporal helper splits and complete price + +## 1. Exact source and interface + +The source is PR5774 at `7d6ec0cdef31d0c37b7d2563e709979caa0d5eae`. +Its full official export is retained in `inputs/pr5774-source.tar`. +The verifier checks its archive digest, manifest, exact source pins and every +payload before import. Each nested archive retains its own source checks. +PLAN.json binds the source and every step by canonical JSON SHA256. + +Use decoded scalar coordinates. The source endpoint is + +```text +T = I + sum e_(r+112) e_r^T, over the 104 live ports r. +``` + +Let G be the independent helper coordinates whose entrance frame is zero and +whose exit frame is the full nine-dimensional space. T is the identity on G. +All public inputs are arbitrary. Every owned input column must be erased by +INIT and return zero. No new public input is treated as clean storage. + +## 2. Time-separated collection and injection + +Fix a frame F, a physical helper h, and a cut at which h occupies F. +A collection plan adds scalar multiples of actual earlier fields at F into +one owned buffer. Its complete input row is c, supported on G. +An injection plan adds multiples of that buffer into actual later fields at F. +Its complete output column is d, also supported on G. Require + +```text +c d = 1, and d_h != 0. +``` + +The plans may use different fields at different times. Every collection occurs +at or before the cut. Every injection occurs at or after it. The verifier +computes c by the full rational prefix history and d by the full reverse +rational suffix history. It checks all public and dirty owned coordinates, +not only the helper block. No inverse of a possibly singular prefix is used. + +A contact inside a MOVE needs an actual subdivision of that paid native query. +For a forward path A to B, require A strictly contained in F strictly contained +in B. Reverse owned paths use the reverse inclusions. The emitted word contains +both queries. Their native maps compose to the original map with its exact +phase. Their separate recursive costs replace the original cost. + +Choose an invertible dyadic basis Q on G such that + +```text +Q e_h = d, and c Q = e_h^T. +``` + +The fixed constructor first adds `-c_j` times coordinate j into h for j!=h, +then scales h by d_h, then adds `d_j/d_h` times h into each j!=h. +The unit pairing proves both identities. Each emitted SCALE has an invertible +dyadic coefficient under the exact scalar checker. All three plans have d_h=1. +Apply Q in the common initial frame. Apply Q inverse in the common final frame. +These operations affect only G, so Q commutes with T. + +Initialize the owned buffer at the first collection. The complete collection +now puts the original independent input x_h in that buffer. At the cut, let y +be the current value in the physical field h. Introduce a fresh independent +public input z at F. The two scalar swaps + +```text +swap(h, buffer) +swap(fresh, buffer) +buffer <- buffer - h +``` + +leave h=x_h, fresh=y and buffer=z-x_h. Each swap is three ADDs and a SCALE by -1. +Retire h at F. Rename its entire remaining source trajectory to fresh. Thus the +old continuation starts with exactly its old value y. The later injection plan +adds d(z-x_h) to the complete source output. Clear the buffer after its last use. + +Before the terminal basis inverse, the continuing source coordinates have +output `T Q x + d(z-x_h)`. After that inverse they have + +```text +T x + e_h(z-x_h). +``` + +The continued h coordinate is therefore z. The retired physical field holds +x_h at F. Every other output retains its prescribed arbitrary-input value. +This gives two independent targets of ranks dim(F) and 9-dim(F) in place of +one rank-nine target. It proves the scalar construction for all inputs. + +The proof uses the actual temporal row and column, a real pivot at the cut, +legal boundary bases, a charged owned lifetime and paid interior access. +A static unit pairing without those conditions is insufficient. + +## 3. Three fixed constructions + +Time2 equals twice the source event index at a boundary. An odd value denotes +the midpoint of that indexed query. Each row below refers to its own exact +step input; event numbers change after each construction. + +| Step | Pivot | Frame | Cut time2 | Collection contacts | Injection contacts | Added queries | New target ranks | +|---|---:|---:|---:|---:|---:|---:|---| +| 1 | 696 | 1031 | 27044 | 1 | 4 | 1 | 5,4 | +| 2 | 623 | 117 | 26314 | 1 | 5 | 1 | 5,4 | +| 3 | 585 | 245 | 34391 | 2 | 1 | 2 | 8,1 | + +In step 1 the buffer collects field696 at time 27026. It injects at times 27044, +27501 and27516. The odd contact subdivides an owned query. Step2 retains its +buffer from time 26314 through 32701 and subdivides a public query. Step3 +collects `-field438` and later `field585`; the full row is exactly e_585. +It splits two rank-two queries into rank-one pairs. Every exact operand, +coefficient and original query is in PLAN.json and WITNESS.json. + +The final word has 770 public inputs and 25 owned labels, 27 owned lifetimes, +and peak 13 live owned fields. It has 25,973 instructions. All 795 labels fit +the retained 1,000-slot allowance. Each added buffer is initialized, retained, +used and cleared at F; it has no uncharged native MOVE. + +## 4. Full invoice and conditional exponent + +Write H_r=r^t for t=1-kappa. Relative to PR5774, the local deltas are + +```text +Delta P = 4H1 - 2H2 + 2H3 + 2H4 - 2H7, +Delta T = H1 + 2H4 + 2H5 + H8 - 3H9. +``` + +The net signed gain is +`-3H1 + 2H2 - 2H3 + 2H5 + 2H7 + H8 - 3H9`. +This package certifies its effect at the stated exponent. It does not claim +that this expression is positive for every 0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6120394867995628289381/1960000000000000000000000", + "fused_gaussian": "6120394867986884868143/1960000000000000000000000", + "global_coordinate_router": "218585531/70000000000", + "group_bit_router": "306019743469344243407/98000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6120394866595628289381/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802370394867995628289381/1960000000000000000000000" + }, + "parameters": { + "a": "218585531/70000000000", + "b": "4371710621/1400000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "1782370394866595628289381/1960000000000000000000000", + "complex_uniform_saving": "2185855311/700000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "78066261/25000000000", + "lambda_": "398750939823/400000000000", + "lambda_prime": "1395628289381/1400000000000", + "layout": "1/1400000000000", + "q": "4371710619/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "624530089/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "19414469/70000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177629605135504371710619/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595628289381/1960000000000000000000000", + "cap_above_band": "802370394866595628289381/1960000000000000000000000", + "cap_below_cell": "177629605132004371710619/1960000000000000000000000", + "cap_below_phase_cell_power": "2137629605133404371710619/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "39378289379/1400000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586884868143/1960000000000000000000000", + "gaussian_above_main": "695628289381/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "349344243407/98000000000000000000000", + "group_gauge_power_slack": "177629605135434371710619/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "697814144691/700000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "695840010400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "2795628289379/1960000000000000000000000", + "leaf_saving_above_effective": "1395628289379/1960000000000000000000000", + "main_transform_above_kappa": "4195628289381/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "26948907072347/350000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "1395628289383/1400000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "2795628289379/1960000000000000000000000", + "q_positive": "4371710619/1400000000000", + "short_record_fallback": "1395628289379/1400000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595628289381/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41790, + "16": 416, + "2": 8136, + "24": 416, + "3": 8964, + "32": 416, + "4": 1764, + "40": 416, + "48": 416, + "5": 2862, + "56": 416, + "6": 126, + "64": 416, + "7": 144, + "72": 208 + }, + "paid_calls": 66906, + "previous_pr5774": "312192127/100000000000", + "productive_fields": 13444, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-736374629429230927492896198814544310527197970272952733660781433/3138550867693340381917894711603833208051177722232017256448", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "3577/100000000000000", + "1789/50000000000000" + ], + "raw_root_interval": [ + "312265047577/100000000000000", + "156132523789/50000000000000" + ], + "relative_gain_percent": "560900/24014779", + "strictification": { + "alpha": { + "lower": "0.999999999968708948987649151976", + "upper": "0.999999999968708948987649151977" + }, + "cutoff": 16, + "delta": { + "lower": "0.953059856502973038954315738822", + "upper": "0.953059856502973038954315738823" + }, + "floor": 17, + "gamma": { + "lower": "0.975717331211066859570647494582", + "upper": "0.975717331211066859570647494583" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "125/128", + "tail_offset": "1/7", + "tested": "624530089/200000000000" + }, + "targets": { + "1": 468, + "145": 208, + "17": 416, + "2": 90, + "25": 416, + "3": 72, + "33": 416, + "4": 1890, + "41": 416, + "49": 416, + "5": 144, + "57": 416, + "65": 416, + "7": 126, + "73": 208, + "8": 396, + "9": 6930 + }, + "whole_idle_jobs": 3120 + }, + "delta_paid": { + "1": 4, + "2": -2, + "3": 2, + "4": 2, + "7": -2 + }, + "delta_targets": { + "1": 1, + "4": 2, + "5": 2, + "8": 1, + "9": -3 + }, + "instructions": 25973, + "limits": [ + "The five inherited framework assumptions remain.", + "This gain is below the requested one percent.", + "The large uniform word and rounded multiplier are not materialized.", + "Author checks are not independent human or formal acceptance.", + "The selected frontier is unchanged." + ], + "local": { + "endpoint_coefficients": 632025, + "helpers": { + "1": 26, + "2": 5, + "3": 4, + "4": 105, + "5": 8, + "7": 7, + "8": 22, + "9": 385 + }, + "owned_fields": 25, + "owned_lifetimes": 27, + "paid": { + "1": 2235, + "2": 452, + "3": 498, + "4": 98, + "5": 159, + "6": 7, + "7": 8 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 224990 + }, + "native": { + "distinct_maps": 2926, + "helper_normalizers": 1124, + "helpers": { + "1": 26, + "2": 5, + "3": 4, + "4": 105, + "5": 8, + "7": 7, + "8": 22, + "9": 385 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "38e208e9d04ea5ff55bd61569224163b195895f446310dd9456ba52b0516d013", + "wrong_phase_rejected": true + }, + "negative_controls": { + "invent_helper_credit": "Every productive helper has a native target", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "omit_buffer_clear": "All public and owned exits", + "omit_continuation_injection": "All public and owned rows", + "omit_history_collection": "All public and owned rows", + "omit_owned_buffer": "Role index", + "omit_paid_access_query": "Common scalar chart", + "omit_paid_query_from_invoice": "Complete field and call counts", + "retain_old_rank_nine_target": "All public and owned exits", + "wrong_fresh_input_frame": "Scalar destination and coefficient" + }, + "physical_caller": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 632025, + "columns": 795 + }, + "source_commit": "7d6ec0cdef31d0c37b7d2563e709979caa0d5eae", + "status": "PASS_P104_ASYNC_HELPER_HUBS_KAPPA_00312265044" +} diff --git a/research/p104-asynchronous-helper-hubs/SOURCES.json b/research/p104-asynchronous-helper-hubs/SOURCES.json new file mode 100644 index 0000000000..3343674d9b --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/SOURCES.json @@ -0,0 +1,298 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/p104-retained-native-copy/LOCAL-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/LOCAL-EDITS.json", + "sha256": "9ef49a2f123519c7c2b750ca6afdbe6dc1a9e99f29aff81bfcb593d758714388", + "git_blob": "abaad1de796e421727f91c132ce3c9bea8068334", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/NOTICE", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/NOTICE", + "sha256": "eccf96753b037fd1f9037487d9a77c62abf117100c24a28a5d0b25d9e1f25176", + "git_blob": "b8818bf7300c1599cc49794254e02e98464f1df3", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PLAN.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PLAN.json", + "sha256": "1476064d57afcabfd43deb0b2b61ce30bb89b603df72645f60dacf00b72fcdbe", + "git_blob": "05723fc4ead9bdc9987ac8147bf8424ece3144d6", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PRICING-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PRICING-EDITS.json", + "sha256": "ea4f275bc47ed3c1e54c598ad1ed2e0d6b3260c444f5a142238c6b88a4700acb", + "git_blob": "27df420ea8a51bdb4d41b23fc94b4c9100200b0d", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PROOF.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PROOF.md", + "sha256": "f7af2ed85c8ce88bc4707a4171503108c4d7083c165fe5929108bf976baaa446", + "git_blob": "b8d8e1cae15bda5c73f5e5dedb54e2730ba049f2", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/README.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/README.md", + "sha256": "1626aadf77c59ba511b6c39bf27f31f78567d6d2ba9c62e04c8f995ba1c73515", + "git_blob": "ee764ad750c4d12d64697a2a470c4a9dfdde03e0", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/RESULT.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/RESULT.json", + "sha256": "a47576bd8f65fb2e4bb250043ccf209d880a704ca3c80c0ff45c0255b3959761", + "git_blob": "47d0ab00efeb9ed78d93463c8c6946b379df65f4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/SOURCES.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/SOURCES.json", + "sha256": "453097edc44d6055ffd4a5a17612f413179d7454923fc09927d500675a7bacdb", + "git_blob": "4711a6a76015d89679f6510139d19c2c0b50ef5b", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/TASK.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/TASK.json", + "sha256": "61556a4e57a17757160f7f809a116ce692839e4ff1f5ce83cdcd382981df0268", + "git_blob": "ea7f8538b06b190cc82c911e6f2b4d2fd66519c1", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/VALIDATION.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VALIDATION.md", + "sha256": "62f05bea3a6cb5152ad0ec11365c75ded233f61184f335085cb81abe870b6a94", + "git_blob": "8fe8f02031dee2ddf2fda7648ce64cedcfd23c03", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/VERIFY.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VERIFY.json", + "sha256": "146fd66ef488919e8779b15ef126ad82ac6ac6b256961e81d62c585823e95f77", + "git_blob": "bf48e45cbbc0327c24eb5325e4e60e7f2a5410a2", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/WITNESS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WITNESS.json", + "sha256": "4c165c2416f162bba3386de2bc617fd44164df942b91b221eb43216916cd70ab", + "git_blob": "0e6e9251e9b07a734eadd8b0c3e154a876e81468", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/WORD.json.gz", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WORD.json.gz", + "sha256": "7c393444fa5b9a6941471d02047beb2aa8285e5614bb052fb85458b69236a38a", + "git_blob": "3ae3c4ebc8fc92098784f717a3107e6fa958dd86", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/construct.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/construct.py", + "sha256": "b29d9fdda07320f0c17c0d6eda1831a78ee69c895c57aeab60be730f0e1f08e1", + "git_blob": "d61f53085d80a361a46ac1412ebfac7500a9c7e4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/inputs/pr5751-source.tar", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/inputs/pr5751-source.tar", + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023", + "git_blob": "89ac4dba7a4e814ffc4737f7af2f8e22fdb117d8", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/local.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/local.py", + "sha256": "0a3664cd5f077e020a62903f093fff6a1617a84a048137bf812af67be9d1b1c8", + "git_blob": "18ca95f48652168245186a13d69c0aa273021ee4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/pricing.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/pricing.py", + "sha256": "0f6f0e33bf78ba35873d4ed103bb089542b84b10388c7a5f4a546c15bb7e4493", + "git_blob": "5a74b4ac99adcbbcf906bf732800574232bd15c9", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/sources.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/sources.py", + "sha256": "fc6f5ebda612e839d61c0a059c10c10ba93787855b9e6077a9ba46200a275988", + "git_blob": "8436b388306654a2603ae0d2bffdde6ab9695123", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/verify.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/verify.py", + "sha256": "9c6e6727c332526ba53cd93a084f6733fdb773f0130eb7fa969fd39c0e500ca7", + "git_blob": "e05fc946e7e67bf4a57ca4a22adb01960449a7c5", + "usage": "provenance" + } + ], + "archived_files": [ + { + "path": "research/p104-retained-native-copy/LOCAL-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/LOCAL-EDITS.json", + "sha256": "9ef49a2f123519c7c2b750ca6afdbe6dc1a9e99f29aff81bfcb593d758714388", + "git_blob": "abaad1de796e421727f91c132ce3c9bea8068334", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/NOTICE", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/NOTICE", + "sha256": "eccf96753b037fd1f9037487d9a77c62abf117100c24a28a5d0b25d9e1f25176", + "git_blob": "b8818bf7300c1599cc49794254e02e98464f1df3", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PLAN.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PLAN.json", + "sha256": "1476064d57afcabfd43deb0b2b61ce30bb89b603df72645f60dacf00b72fcdbe", + "git_blob": "05723fc4ead9bdc9987ac8147bf8424ece3144d6", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PRICING-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PRICING-EDITS.json", + "sha256": "ea4f275bc47ed3c1e54c598ad1ed2e0d6b3260c444f5a142238c6b88a4700acb", + "git_blob": "27df420ea8a51bdb4d41b23fc94b4c9100200b0d", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/PROOF.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PROOF.md", + "sha256": "f7af2ed85c8ce88bc4707a4171503108c4d7083c165fe5929108bf976baaa446", + "git_blob": "b8d8e1cae15bda5c73f5e5dedb54e2730ba049f2", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/README.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/README.md", + "sha256": "1626aadf77c59ba511b6c39bf27f31f78567d6d2ba9c62e04c8f995ba1c73515", + "git_blob": "ee764ad750c4d12d64697a2a470c4a9dfdde03e0", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/RESULT.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/RESULT.json", + "sha256": "a47576bd8f65fb2e4bb250043ccf209d880a704ca3c80c0ff45c0255b3959761", + "git_blob": "47d0ab00efeb9ed78d93463c8c6946b379df65f4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/SOURCES.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/SOURCES.json", + "sha256": "453097edc44d6055ffd4a5a17612f413179d7454923fc09927d500675a7bacdb", + "git_blob": "4711a6a76015d89679f6510139d19c2c0b50ef5b", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/TASK.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/TASK.json", + "sha256": "61556a4e57a17757160f7f809a116ce692839e4ff1f5ce83cdcd382981df0268", + "git_blob": "ea7f8538b06b190cc82c911e6f2b4d2fd66519c1", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/VALIDATION.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VALIDATION.md", + "sha256": "62f05bea3a6cb5152ad0ec11365c75ded233f61184f335085cb81abe870b6a94", + "git_blob": "8fe8f02031dee2ddf2fda7648ce64cedcfd23c03", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/VERIFY.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VERIFY.json", + "sha256": "146fd66ef488919e8779b15ef126ad82ac6ac6b256961e81d62c585823e95f77", + "git_blob": "bf48e45cbbc0327c24eb5325e4e60e7f2a5410a2", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/WITNESS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WITNESS.json", + "sha256": "4c165c2416f162bba3386de2bc617fd44164df942b91b221eb43216916cd70ab", + "git_blob": "0e6e9251e9b07a734eadd8b0c3e154a876e81468", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/WORD.json.gz", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WORD.json.gz", + "sha256": "7c393444fa5b9a6941471d02047beb2aa8285e5614bb052fb85458b69236a38a", + "git_blob": "3ae3c4ebc8fc92098784f717a3107e6fa958dd86", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/construct.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/construct.py", + "sha256": "b29d9fdda07320f0c17c0d6eda1831a78ee69c895c57aeab60be730f0e1f08e1", + "git_blob": "d61f53085d80a361a46ac1412ebfac7500a9c7e4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/inputs/pr5751-source.tar", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/inputs/pr5751-source.tar", + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023", + "git_blob": "89ac4dba7a4e814ffc4737f7af2f8e22fdb117d8", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/local.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/local.py", + "sha256": "0a3664cd5f077e020a62903f093fff6a1617a84a048137bf812af67be9d1b1c8", + "git_blob": "18ca95f48652168245186a13d69c0aa273021ee4", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/pricing.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/pricing.py", + "sha256": "0f6f0e33bf78ba35873d4ed103bb089542b84b10388c7a5f4a546c15bb7e4493", + "git_blob": "5a74b4ac99adcbbcf906bf732800574232bd15c9", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/sources.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/sources.py", + "sha256": "fc6f5ebda612e839d61c0a059c10c10ba93787855b9e6077a9ba46200a275988", + "git_blob": "8436b388306654a2603ae0d2bffdde6ab9695123", + "usage": "provenance" + }, + { + "path": "research/p104-retained-native-copy/verify.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/verify.py", + "sha256": "9c6e6727c332526ba53cd93a084f6733fdb773f0130eb7fa969fd39c0e500ca7", + "git_blob": "e05fc946e7e67bf4a57ca4a22adb01960449a7c5", + "usage": "provenance" + } + ], + "direct_sources": [], + "source_export": { + "commit": "7d6ec0cdef31d0c37b7d2563e709979caa0d5eae", + "package": "research/p104-retained-native-copy", + "files": 19, + "local_path": "inputs/pr5774-source.tar", + "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497", + "git_blob": "f34972476e76121c7cbb0e86478eaa86969c6efd", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5774" + }, + "source_custody": "Authenticate the complete official PR5774 export and every payload before import. The nested exports retain all earlier source checks. Runtime replay needs no Git or network.", + "attribution": "Asynchronous helper hubs: Ali Romman with substantial OpenAI Codex assistance. PR5774 supplies the retained-copy word. PR5751 supplies the earlier paid meetings. Every predecessor notice is retained." +} diff --git a/research/p104-asynchronous-helper-hubs/TASK.json b/research/p104-asynchronous-helper-hubs/TASK.json new file mode 100644 index 0000000000..561f2501d8 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/TASK.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 8, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a changed helper inventory earn productive credit that survives completion, compilation and the actual caller?", + "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" + ], + "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": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Specify all arbitrary inputs, owned fields, restored outputs and a physically legal consumer. Compare complete P and T, including target debits and precision/stock costs. #5599 is a positive control for target refinement, not permission to split every helper for free. #5614 is a hypothetical compiler budget, not an emitted 145-split word. Stop at the first unpaid boundary or a failing optimistic full bill.", + "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": [ + "productive helper", + "target refinement", + "5599", + "5614" + ], + "existing_checks": [ + { + "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" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Three independent helper splits with time-separated scalar collection and injection on exact PR5774.", + "scope_change_reason": "The contact contract permits a retained owned buffer and paid interior access points. This changes the simultaneous-bank premise of the earlier paid meetings.", + "bottleneck_link": "Three new independent productive inputs change the complete target moment. Four additional paid queries and all owned costs are charged.", + "budget_minutes": 180, + "stop_rule": "Publish only after exact scalar, temporal, native, physical caller, complete price, compiler and source checks. This small result does not complete the donor request for a major gain.", + "outcome": "completed", + "evidence": "PROOF.md, PLAN.json, WITNESS.json, RESULT.json and the registered verifier.", + "author": "Ali Romman with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for the construction, proof, search and verification. No subagents.", + "open_questions": [ + { + "question": "Can one exact hub support several independent helper channels with fewer shared access queries?", + "why_it_matters": "A block of channels can share a paid access point and improve the signed moment more than separate cuts.", + "first_step": "Use the temporal identities in WITNESS.json to form a matrix pairing and check legal dyadic boundary bases. Recount every shared query and owned field.", + "blocked_by": "A unit pairing matrix alone does not prove a physical schedule or full-price gain." + }, + { + "question": "Can time-separated contacts remove a paid rank instead of only refining target credit?", + "why_it_matters": "The present relative kappa gain is below one percent. A paid-rank reduction can have a larger effect.", + "first_step": "Specify one source-version channel, an explicit changed native itinerary and a complete signed invoice before expanding a search.", + "blocked_by": "Delivery, arbitrary-input restoration and complete native/caller pricing remain necessary." + } + ] +} diff --git a/research/p104-asynchronous-helper-hubs/VALIDATION.md b/research/p104-asynchronous-helper-hubs/VALIDATION.md new file mode 100644 index 0000000000..f9bd299eda --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/VALIDATION.md @@ -0,0 +1,41 @@ +# Validation + +Base main is `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priorities revision 8. +The selected record stayed 0.00310045. The exact source is PR5774 at +`7d6ec0cdef31d0c37b7d2563e709979caa0d5eae`. + +The source-bound selected baseline passed. The complete remote overlap snapshot +from October 26 at 16:44UTC covered 315 open PRs and paginated Discussions. +Later live PR and Discussion reads found the stronger PR5774 and its released +scope. The three hubs were rebuilt on that exact word. The active scalar-event +reframe and noncommuting controller scopes were kept separate. Sparse local +notes and unpublished work remain outside overlap coverage. + +Python 3.12.13 on macOS was used. The replay needs only the standard library. +The primary command passed all temporal, scalar, ownership, native, caller, +price, compiler and outer checks, including the actual negative controls: + +```sh +python3.12 -W error -B research/p104-asynchronous-helper-hubs/verify.py --write +``` + +The registered replay runs both normal and optimized modes. It must reproduce +every WORD, WITNESS and RESULT field: + +```sh +python3.12 -B scripts/research_package.py --package research/p104-asynchronous-helper-hubs --check-only +python3.12 -B scripts/research_package.py --package research/p104-asynchronous-helper-hubs +``` + +Publication checks must verify committed bytes, export integrity and a separate +read-only, Git-free optimized replay. The publication record will give the +exact commit and export digest. Full-history preflight is not claimed in this +shallow checkout. Hosted scientific CI and independent acceptance remain +separate obligations. + +The metadata/pin check passed. The registered normal and optimized replays both +passed and reproduced every retained output field. All 795 columns, 632,025 +coefficients, 2,926 native maps, the full physical caller, both rational price +engines, compiler and outer checks passed. All ten word/caller/invoice controls +and the native phase control rejected their altered inputs. The scientific +marker and `PASS_REGISTERED_RESEARCH_PACKAGE` were present in both runs. diff --git a/research/p104-asynchronous-helper-hubs/VERIFY.json b/research/p104-asynchronous-helper-hubs/VERIFY.json new file mode 100644 index 0000000000..5550c891e8 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/VERIFY.json @@ -0,0 +1,28 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Authenticated source, exact constructor, all arbitrary-input/transpose/native/caller obligations, complete charged pricing and actual rejection controls.", + "timeout_seconds": 600 + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "checks": "Authenticated source, exact constructor, all arbitrary-input/transpose/native/caller obligations, complete charged pricing and actual rejection controls.", + "timeout_seconds": 600 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-asynchronous-helper-hubs/WITNESS.json b/research/p104-asynchronous-helper-hubs/WITNESS.json new file mode 100644 index 0000000000..8ea4538a93 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/WITNESS.json @@ -0,0 +1,554 @@ +[ + { + "buffer": 790, + "buffer_start_time2": 27026, + "buffer_stop_time2": 27516, + "collection": [ + { + "coefficient": "1", + "role": 696, + "time2": 27026 + } + ], + "frame": 1031, + "injection": [ + { + "coefficient": "1", + "role": 696, + "time2": 27044 + }, + { + "coefficient": "1", + "role": 697, + "time2": 27044 + }, + { + "coefficient": "1", + "role": 770, + "time2": 27501 + }, + { + "coefficient": "1", + "role": 699, + "time2": 27516 + } + ], + "input": { + "696": "1" + }, + "input_basis": [ + [ + "ADD", + 133, + 696, + "2", + 3 + ], + [ + "ADD", + 697, + 696, + "1", + 3 + ], + [ + "ADD", + 699, + 696, + "1", + 3 + ], + [ + "ADD", + 709, + 696, + "1", + 3 + ], + [ + "ADD", + 733, + 696, + "1", + 3 + ] + ], + "local": { + "endpoint_coefficients": 625681, + "helpers": { + "1": 25, + "2": 5, + "3": 4, + "4": 104, + "5": 7, + "7": 7, + "8": 21, + "9": 387 + }, + "owned_fields": 23, + "owned_lifetimes": 25, + "paid": { + "1": 2231, + "2": 454, + "3": 497, + "4": 97, + "5": 159, + "6": 7, + "7": 9 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 12, + "public_inputs": 768, + "real_scalar_allowance": 224482 + }, + "output": { + "133": "2", + "696": "1", + "697": "1", + "699": "1", + "709": "1", + "733": "1" + }, + "output_inverse": [ + [ + "ADD", + 733, + 696, + "-1", + 127 + ], + [ + "ADD", + 709, + 696, + "-1", + 127 + ], + [ + "ADD", + 699, + 696, + "-1", + 127 + ], + [ + "ADD", + 697, + 696, + "-1", + 127 + ], + [ + "ADD", + 133, + 696, + "-2", + 127 + ] + ], + "paid_access_points": [ + [ + "MOVE", + 770, + 591, + 597, + true + ] + ], + "pivot": 696, + "time2": 27044 + }, + { + "buffer": 792, + "buffer_start_time2": 26314, + "buffer_stop_time2": 32701, + "collection": [ + { + "coefficient": "1", + "role": 623, + "time2": 26314 + } + ], + "frame": 117, + "injection": [ + { + "coefficient": "1", + "role": 624, + "time2": 26318 + }, + { + "coefficient": "-1/2", + "role": 627, + "time2": 26330 + }, + { + "coefficient": "-1/2", + "role": 629, + "time2": 26332 + }, + { + "coefficient": "1/2", + "role": 629, + "time2": 26336 + }, + { + "coefficient": "1/2", + "role": 732, + "time2": 32701 + } + ], + "input": { + "623": "1" + }, + "input_basis": [ + [ + "ADD", + 205, + 623, + "1", + 3 + ], + [ + "ADD", + 546, + 623, + "-2", + 3 + ], + [ + "ADD", + 547, + 623, + "2", + 3 + ], + [ + "ADD", + 548, + 623, + "2", + 3 + ], + [ + "ADD", + 549, + 623, + "2", + 3 + ], + [ + "ADD", + 558, + 623, + "-4", + 3 + ], + [ + "ADD", + 568, + 623, + "4", + 3 + ], + [ + "ADD", + 569, + 623, + "2", + 3 + ], + [ + "ADD", + 570, + 623, + "4", + 3 + ], + [ + "ADD", + 575, + 623, + "2", + 3 + ], + [ + "ADD", + 576, + 623, + "2", + 3 + ], + [ + "ADD", + 624, + 623, + "1", + 3 + ], + [ + "ADD", + 625, + 623, + "-1", + 3 + ], + [ + "ADD", + 627, + 623, + "-1/2", + 3 + ], + [ + "ADD", + 732, + 623, + "1/2", + 3 + ] + ], + "local": { + "endpoint_coefficients": 628849, + "helpers": { + "1": 25, + "2": 5, + "3": 4, + "4": 105, + "5": 8, + "7": 7, + "8": 21, + "9": 386 + }, + "owned_fields": 24, + "owned_lifetimes": 26, + "paid": { + "1": 2231, + "2": 454, + "3": 498, + "4": 98, + "5": 159, + "6": 7, + "7": 8 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 13, + "public_inputs": 769, + "real_scalar_allowance": 224902 + }, + "output": { + "205": "1", + "546": "-2", + "547": "2", + "548": "2", + "549": "2", + "558": "-4", + "568": "4", + "569": "2", + "570": "4", + "575": "2", + "576": "2", + "623": "1", + "624": "1", + "625": "-1", + "627": "-1/2", + "732": "1/2" + }, + "output_inverse": [ + [ + "ADD", + 732, + 623, + "-1/2", + 127 + ], + [ + "ADD", + 627, + 623, + "1/2", + 127 + ], + [ + "ADD", + 625, + 623, + "1", + 127 + ], + [ + "ADD", + 624, + 623, + "-1", + 127 + ], + [ + "ADD", + 576, + 623, + "-2", + 127 + ], + [ + "ADD", + 575, + 623, + "-2", + 127 + ], + [ + "ADD", + 570, + 623, + "-4", + 127 + ], + [ + "ADD", + 569, + 623, + "-2", + 127 + ], + [ + "ADD", + 568, + 623, + "-4", + 127 + ], + [ + "ADD", + 558, + 623, + "4", + 127 + ], + [ + "ADD", + 549, + 623, + "-2", + 127 + ], + [ + "ADD", + 548, + 623, + "-2", + 127 + ], + [ + "ADD", + 547, + 623, + "-2", + 127 + ], + [ + "ADD", + 546, + 623, + "2", + 127 + ], + [ + "ADD", + 205, + 623, + "-1", + 127 + ] + ], + "paid_access_points": [ + [ + "MOVE", + 732, + 594, + 222, + false + ] + ], + "pivot": 623, + "time2": 26314 + }, + { + "buffer": 794, + "buffer_start_time2": 31557, + "buffer_stop_time2": 34391, + "collection": [ + { + "coefficient": "-1", + "role": 438, + "time2": 31557 + }, + { + "coefficient": "1", + "role": 585, + "time2": 34391 + } + ], + "frame": 245, + "injection": [ + { + "coefficient": "1", + "role": 585, + "time2": 34391 + } + ], + "input": { + "585": "1" + }, + "input_basis": [], + "local": { + "endpoint_coefficients": 632025, + "helpers": { + "1": 26, + "2": 5, + "3": 4, + "4": 105, + "5": 8, + "7": 7, + "8": 22, + "9": 385 + }, + "owned_fields": 25, + "owned_lifetimes": 27, + "paid": { + "1": 2235, + "2": 452, + "3": 498, + "4": 98, + "5": 159, + "6": 7, + "7": 8 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 224990 + }, + "output": { + "585": "1" + }, + "output_inverse": [], + "paid_access_points": [ + [ + "MOVE", + 438, + 911, + 127, + false + ], + [ + "MOVE", + 585, + 918, + 127, + false + ] + ], + "pivot": 585, + "time2": 34391 + } +] diff --git a/research/p104-asynchronous-helper-hubs/WORD.json.gz b/research/p104-asynchronous-helper-hubs/WORD.json.gz new file mode 100644 index 0000000000..e58322c358 Binary files /dev/null and b/research/p104-asynchronous-helper-hubs/WORD.json.gz differ diff --git a/research/p104-asynchronous-helper-hubs/construct.py b/research/p104-asynchronous-helper-hubs/construct.py new file mode 100644 index 0000000000..4cc7004b89 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/construct.py @@ -0,0 +1,175 @@ +"""Split a helper with a retained buffer and time-separated scalar contacts. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +NOTICE retains all source credit. +""" +from collections import defaultdict +from copy import deepcopy +from fractions import Fraction as Q + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def add(dst, src, coefficient): + for index, value in tuple(src.items()): + result = dst.get(index, Q(0)) + coefficient*value + if result: + dst[index] = result + else: + dst.pop(index, None) + + +def inverse(events): + return [[e[0], *e[1:-2], str(1/Q(e[-2]) if e[0] == 'SCALE' else -Q(e[-2])), e[-1]] + for e in reversed(events)] + + +def boundary_basis(c, d, pivot, frame): + need(sum(c.get(r, Q(0))*v for r, v in d.items()) == 1 and d.get(pivot), + 'Unit pairing and nonzero physical pivot') + events = [['ADD', pivot, r, str(-q), frame] for r, q in sorted(c.items()) if r != pivot] + if d[pivot] != 1: + events.append(['SCALE', pivot, str(d[pivot]), frame]) + events.extend(['ADD', r, pivot, str(q/d[pivot]), frame] + for r, q in sorted(d.items()) if r != pivot) + return events + + +def history_identity(word, plan): + """Compute the input row and output column at the exact contact times.""" + size = word['public']+word['owned_fields'] + collected, delivered = {}, {} + tables = [] + for name in ('collection', 'injection'): + table = defaultdict(list) + for item in plan[name]: + time = item['time2'] + need(type(time) is int and 0 <= time <= 2*len(word['program']), 'Contact time') + need(time % 2 == 0 or time//2 in plan['queries'], 'Paid interior contact') + table[time].append((item['role'], Q(item['coefficient']))) + tables.append(table) + + def observe(table, time, rows, total): + for role, q in table.get(time, []): + need(0 <= role < size and q, 'Actual nonzero contact operand') + add(total, rows[role], q) + + rows = [{r: Q(1)} for r in range(size)] + for index, event in enumerate(word['program']): + observe(tables[0], 2*index, rows, collected) + op, role = event[:2] + if op == 'MOVE': + observe(tables[0], 2*index+1, rows, collected) + elif op in ('INIT', 'CLEAR'): + rows[role] = {} + elif op == 'SCALE': + rows[role] = {r: Q(event[-2])*v for r, v in rows[role].items()} + elif op == 'COPY': + rows[role] = {r: Q(event[-2])*v for r, v in rows[event[2]].items()} + else: + need(op == 'ADD', 'Source opcode') + add(rows[role], rows[event[2]], Q(event[-2])) + observe(tables[0], 2*len(word['program']), rows, collected) + + columns = [{r: Q(1)} for r in range(size)] + observe(tables[1], 2*len(word['program']), columns, delivered) + for index in reversed(range(len(word['program']))): + event = word['program'][index] + op, role = event[:2] + if op in ('INIT', 'CLEAR'): + columns[role] = {} + elif op == 'SCALE': + columns[role] = {r: Q(event[-2])*v for r, v in columns[role].items()} + elif op in ('ADD', 'COPY'): + add(columns[event[2]], columns[role], Q(event[-2])) + if op == 'COPY': + columns[role] = {} + observe(tables[1], 2*index, columns, delivered) + if op == 'MOVE': + observe(tables[1], 2*index+1, columns, delivered) + c = {int(r): Q(q) for r, q in plan['input'].items()} + d = {int(r): Q(q) for r, q in plan['output'].items()} + need(collected == c and delivered == d, 'Complete temporal input and output identities') + main = set(word['live']) | {r+112 for r in word['live']} + eligible = {r for r in range(word['public']) if r not in main + and word['initial'][r] == 3 and word['final'][r] == 127} + need(set(c) | set(d) <= eligible, 'Only independent full-boundary helpers') + return c, d + + +def construct(source, plan): + word = deepcopy(source) + public, owned = word['public'], word['owned_fields'] + pivot, frame, cut = plan['pivot'], plan['frame'], plan['time2'] + buffer = public+1+owned + need(plan['buffer'] == buffer, 'Fixed owned buffer label') + c, d = history_identity(source, plan) + before = boundary_basis(c, d, pivot, 3) + after = inverse(before) + for event in after: + event[-1] = 127 + queries = set(plan['queries']) + need(len(queries) == len(plan['queries']), 'Distinct paid access points') + need([source['program'][i] for i in sorted(queries)] == plan['query_events'], + 'Exact paid source queries') + collection, injection = defaultdict(list), defaultdict(list) + for name, table in (('collection', collection), ('injection', injection)): + for item in plan[name]: + table[item['time2']].append((item['role'], Q(item['coefficient']))) + first, last = min(collection), max(injection) + need(first <= max(collection) <= cut <= min(injection) <= last, 'Causal contact order') + need(cut % 2 == 0 or cut//2 in queries, 'Physical pivot access') + + def rename(event, continuation): + event = event.copy() + for index in (1, 2) if event[0] in ('ADD', 'COPY') else (1,): + role = event[index] + event[index] = public if continuation and role == pivot else role+1 if role >= public else role + return event + + def swap(a, b): + return [['ADD', a, b, '1', frame], ['ADD', b, a, '-1', frame], + ['ADD', a, b, '1', frame], ['SCALE', b, '-1', frame]] + + program = list(before) + + def at(time): + if time == first: + program.append(['INIT', buffer, frame]) + for role, q in collection.get(time, []): + program.append(['ADD', buffer, role+1 if role >= public else role, str(q), frame]) + if time == cut: + program.extend(swap(pivot, buffer)) + program.extend(swap(public, buffer)) + program.append(['ADD', buffer, pivot, '-1', frame]) + for role, q in injection.get(time, []): + target = public if role == pivot else role+1 if role >= public else role + program.append(['ADD', target, buffer, str(q), frame]) + if time == last: + program.append(['CLEAR', buffer, frame]) + + for index, event in enumerate(word['program']): + at(2*index) + if index in queries: + need(event[0] == 'MOVE', 'Subdivide an actual native query') + program.append(rename(['MOVE', event[1], event[2], frame, event[4]], 2*index >= cut)) + at(2*index+1) + program.append(rename(['MOVE', event[1], frame, event[3], event[4]], 2*index+1 >= cut)) + else: + program.append(rename(event, 2*index >= cut)) + at(2*len(word['program'])) + program.extend(rename(event, True) for event in after) + word.update(program=program, public=public+1, owned_fields=owned+1, + schema='p104-asynchronous-helper-hubs/1') + word['initial'].append(frame) + word['final'].append(word['final'][pivot]) + word['final'][pivot] = frame + return word, {'pivot': pivot, 'frame': frame, 'time2': cut, 'buffer': buffer, + 'collection': plan['collection'], 'injection': plan['injection'], + 'input': plan['input'], 'output': plan['output'], + 'paid_access_points': plan['query_events'], + 'input_basis': before, 'output_inverse': after, + 'buffer_start_time2': first, 'buffer_stop_time2': last} diff --git a/research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar b/research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar new file mode 100644 index 0000000000..f34972476e Binary files /dev/null and b/research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar differ diff --git a/research/p104-asynchronous-helper-hubs/local.py b/research/p104-asynchronous-helper-hubs/local.py new file mode 100644 index 0000000000..1cd672569a --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/local.py @@ -0,0 +1,208 @@ +"""Check the complete P104 word with an independent helper inventory. + +Adapted from Ali Romman's PR5544/5545. David Arias supplied the word; +Cinna Davis supplied private reuse; Gareth Davidson supplied composition. +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +def need(ok, why): + if not ok: + raise ValueError(why) + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + +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) + +def span(basis): + out = {0} + for v in basis: + need(type(v) is int and 0 < v < 512 and v not in out, 'Independent binary basis') + out |= {x ^ v for x in tuple(out)} + return frozenset(out) + +def replay(w): + public = w['public'] + owned = w.get('owned_fields', 8) + need(type(owned) is int and 8 <= owned <= 25, 'Owned inventory bound') + need(type(public) is int and 767 <= public <= 770, 'Public inventory bound') + need(len(w['initial']) == len(w['final']) == public, 'Public boundary size') + need(len(w['program']) < 26000, 'Fixed operation bound') + frames = [span(x) for x in w['frames']] + rows = [{r:Q(1)} for r in range(public+owned)] + current = list(w['initial']) + [None]*owned + paid, scalar, live_owned, peak = Counter(), 0, set(), 0 + lifetimes = 0 + for e in w['program']: + op, r = e[:2] + need(0 <= r < public+owned, 'Role index') + if op == 'MOVE': + _, r, a, b, private = e + need(current[r] == a and (r in live_owned) == private, 'Transport source and ownership') + need(frames[b] < frames[a] if private else frames[a] < frames[b], 'Nested chronological transport') + paid[abs(len(w['frames'][b])-len(w['frames'][a]))] += 1 + current[r] = b + elif op == 'INIT': + need(r >= public and r not in live_owned, 'Owned initialization') + live_owned.add(r) + lifetimes += 1 + peak = max(peak, len(live_owned)) + rows[r] = {} + current[r] = e[2] + scalar += 2 + elif op == 'CLEAR': + need(r in live_owned and current[r] == e[2], 'Owned erasure at declared frame') + rows[r] = {} + current[r] = None + live_owned.remove(r) + scalar += 2 + else: + q, f = Q(e[-2]), e[-1] + need(q and current[r] == f, 'Scalar destination and coefficient') + n, d = abs(q.numerator), q.denominator + need(d & (d-1) == 0, 'Dyadic scalar coefficient') + need(abs(q)+1 < 2**16, 'Fixed scalar growth bound') + if op == 'SCALE': + need(n & (n-1) == 0, 'Dyadic unit SCALE') + rows[r] = {k:q*x for k,x in rows[r].items()} + scalar += 2*(abs(n.bit_length()-d.bit_length()) + int(q < 0)) + else: + s = e[2] + need(s != r and 0 <= s < public+owned and current[s] == f, 'Common scalar chart') + if op == 'COPY': + need(r in live_owned and not rows[r], 'COPY into cleared owned field') + rows[r] = {k:q*x for k,x in rows[s].items()} + else: + need(op == 'ADD', 'Scalar opcode') + add(rows[r], rows[s], q) + scalar += 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1) + need(not live_owned and 0 < peak <= 13 and current[:public] == w['final'], 'All public and owned exits') + live = set(w['live']) + for r,row in enumerate(rows): + expected = {r:Q(1)} if r < public else {} + if r-112 in live: + expected[r-112] = Q(1) + need(row == expected, 'All public and owned rows') + main = live | {r+112 for r in live} + helpers = Counter(len(w['frames'][w['final'][r]])-len(w['frames'][w['initial'][r]]) for r in range(public) if r not in main) + need(len(live) == len(w['ports']) == 104 and len(main) == 208 and min(helpers) > 0, 'Independent productive inputs') + return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_fields':owned, 'owned_lifetimes':lifetimes, + 'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+owned)*(public+owned), + 'paid_rank_mass':sum(r*count for r,count in paid.items())} + +def reverse_columns(w): + """Check the transpose with dense dyadic rows and the reverse chronology.""" + public = w['public'] + n = public+w.get('owned_fields', 8) + rows = [[int(i == j) for j in range(n)] for i in range(n)] + exponents = [0]*n + for e in reversed(w['program']): + op,r = e[:2] + if op == 'MOVE': + continue + if op in ('INIT','CLEAR'): + rows[r] = [0]*n + exponents[r] = 0 + continue + q = Q(e[-2]) + qe = q.denominator.bit_length()-1 + if op == 'SCALE': + rows[r] = [q.numerator*x for x in rows[r]] + exponents[r] += qe + else: + s = e[2] + level = max(exponents[s], exponents[r]+qe) + a, b = 1 << (level-exponents[s]), q.numerator << (level-exponents[r]-qe) + rows[s] = [a*x+b*y for x,y in zip(rows[s],rows[r])] + exponents[s] = level + if op == 'COPY': + rows[r] = [0]*n + exponents[r] = 0 + r = s + while exponents[r] and not any(x & 1 for x in rows[r]): + rows[r] = [x//2 for x in rows[r]] + exponents[r] -= 1 + for r,row in enumerate(rows): + expected = [0]*n + if r < public: + expected[r] = 1 << exponents[r] + if r in w['live']: + expected[r+112] = 1 << exponents[r] + need(row == expected, 'Independent dense transpose columns') + return {'columns':n, 'coefficients':n*n, 'arithmetic':'Dense integer rows with binary denominators; reverse chronology'} + +def native(w): + n = w['public'] + C = load(ROOT/'research/p104-native-channel/vendor/clifford_exact.py', 'p104_productive_clifford') + V = load(ROOT/'research/p104-native-channel/vendor/native_verify.py', 'p104_productive_gaussian') + @lru_cache(None) + def chart(i): + return C.canonical_frame(9, tuple(w['frames'][i])) + recipes = {} + def check(a,b): + if (a,b) not in recipes: + recipe,_ = C.lower_child(chart(a).adjoint().then(chart(b))) + expected = V.adjoint(V.frame(w['frames'][a],9)) + V.frame(w['frames'][b],9) + V.equal(V.recipe(recipe),expected,'Native chart change and exact global phase') + need(recipe['rank'] == abs(len(w['frames'][a])-len(w['frames'][b])), 'Native boundary rank') + recipes[a,b] = recipe + return recipes[a,b] + for e in w['program']: + if e[0] == 'MOVE': + check(e[2],e[3]) + main = set(w['live']) | {r+112 for r in w['live']} + helper_profile = Counter() + for r in range(n): + if r not in main: + helper_profile[check(w['initial'][r],w['final'][r])['rank']] += 1 + adapters = [] + for r,q in zip(w['live'],w['ports']): + need(w['frames'][w['initial'][r]] == [q], 'Literal central port') + need(span(w['frames'][w['final'][r+112]]) == frozenset(x for x in range(512) if not (x&q).bit_count()%2), 'Literal output hyperplane') + tests = [ + (C.cgate(9,q,1).adjoint().then(chart(w['initial'][r])), V.adjoint((('C',q,1),))+V.frame(w['frames'][w['initial'][r]],9)), + (chart(w['final'][r+112]).adjoint().then(C.cgate(9,q,-1).then(C.fourier(9))), V.adjoint(V.frame(w['frames'][w['final'][r+112]],9))+(('C',q,-1),)+V.fourier(9))] + for actual,expected in tests: + recipe,_ = C.lower_child(actual) + need(recipe['rank'] == 0, 'Free intrinsic main adapter') + V.equal(V.recipe(recipe),expected,'Main endpoint phase') + adapters.append(recipe) + bad = json.loads(json.dumps(next(iter(recipes.values())))) + bad['left']['phase'] = (bad['left']['phase']+1)%4 + a,b = next(iter(recipes)) + try: + V.equal(V.recipe(bad),V.adjoint(V.frame(w['frames'][a],9))+V.frame(w['frames'][b],9),'Wrong phase control') + except ValueError: + pass + else: + raise ValueError('Wrong native phase accepted') + payload = [[a,b,recipes[a,b]] for a,b in sorted(recipes)] + adapters + return {'distinct_maps':len(recipes),'main_adapters':len(adapters),'helper_normalizers':2*sum(helper_profile.values()), + 'helpers':dict(helper_profile),'recipe_payload_sha256':sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest(), + 'wrong_phase_rejected':True, 'proof':'Every signed Pauli image and exact global phase; frame induction at every positive tensor width'} diff --git a/research/p104-asynchronous-helper-hubs/pricing.py b/research/p104-asynchronous-helper-hubs/pricing.py new file mode 100644 index 0000000000..0fc0ca2a11 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/pricing.py @@ -0,0 +1,184 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +The paid A2 change is from zxv PR5643. The three helper relations are from +Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance. +The four interior basis changes are by Ali Romman with Codex assistance. +Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00312265044'), Q('.003122650445') +PREVIOUS = Q('.00312192127') + + +def encode(x): + if isinstance(x,Q): + return str(x) + if isinstance(x,dict): + return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): + return [encode(v) for v in x] + return x + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter() + L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target') + for e in word['physical_events']: + counts[e[0]] += 1 + if e[0] == 'LOCAL': + L.need(e[3] is False, 'Every source invocation is forward') + paid.update(local['paid']) + targets.update(local['helpers']) + elif e[0] == 'QUERY_SHEAR': + paid[1] += 104 + elif e[0] == 'IDLE': + paid[8*len(e[2])] += 208 + main = Counter() + idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'}) + for e in word['physical_events']: + if e[0] == 'IDLE': + idle[8*len(e[2])] += 208 + L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank') + for term in word['diagonal']: + main[1+8*sum(term[1:])] += 104 + L.need(main == physical['main_targets'], 'Every main target has its full native phase') + targets.update(main) + L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census') + # Recount by the two path lengths, without using emitted main diagonals. + second_t = Counter({r:18*n for r,n in local['helpers'].items()}) + second_p = Counter({r:18*n for r,n in local['paid'].items()}) + second_t[145] += 208 + second_p[1] += 15*104 + for length in (7,8): + for j in range(1,length+1): + second_t[1+8*(j+1)] += 208 + second_p[8*(j+1)] += 208 + L.need((targets,paid) == (second_t,second_p), 'Independent full invoice') + L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks') + L.need(sum(targets.values()) == 13444 and sum(paid.values()) == 66906, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + alpha = E.divide(paid,target) + gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + reserve,decay = Q(1,10**12),Q(125,128) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target)) + L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count') + old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target)) + L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') + return encode({'kappa':KAPPA,'kappa_decimal':'0.00312265044','previous_pr5774':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), + 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40', + 'source_offset':'Rejected at cutoff16 with tail offset1/5', + 'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-asynchronous-helper-hubs/sources.py b/research/p104-asynchronous-helper-hubs/sources.py new file mode 100644 index 0000000000..76d152d2e1 --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/sources.py @@ -0,0 +1,74 @@ +"""Authenticate the retained PR5774 export before any source import. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +PR5774 source interface: Ali Romman with substantial OpenAI Codex assistance. +Rebound to PR5774 by Ali Romman with substantial OpenAI Codex assistance. +The archive checks follow the repository exporter and flyingviper's PR5613. +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import io +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +@contextmanager +def sources(): + pins = json.loads((HERE/'SOURCES.json').read_bytes()) + for row in pins['direct_sources']: + payload = (HERE/row['local_path']).read_bytes() + need(sha256(payload).hexdigest() == row['sha256'], 'Exact direct source SHA256') + need(sha1(b'blob '+str(len(payload)).encode()+b'\0'+payload).hexdigest() == row['git_blob'], + 'Exact direct source Git blob') + pin = pins['source_export'] + raw = (HERE/pin['local_path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'Exact predecessor archive SHA256') + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'Exact retained archive Git blob') + with tempfile.TemporaryDirectory(prefix='p104-paid-main-source-') as directory: + root, names = Path(directory), set() + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:') as bundle: + for member in bundle.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and '\\' not in member.name and ':' not in member.name, + 'Regular relative source path') + need(member.name not in names, 'Unique source path') + names.add(member.name) + target = root.joinpath(*path.parts) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(bundle.extractfile(member).read()) + manifest = json.loads((root/'.research-export.json').read_bytes()) + need(manifest['commit'] == pin['commit'] and manifest['package'] == pin['package'] + and len(manifest['files']) == pin['files'], 'Exact source commit and inventory') + need(names == {'.research-export.json'} | {r['path'] for r in manifest['files']}, + 'No missing or additional source payload') + origins = {row['path']: row for row in pins['archived_files']} + for row in manifest['files']: + origin = origins[row['path']] + need(origin['pin'] == 'head:'+pin['commit']+':'+row['path'] + and origin['sha256'] == row['sha256'], + 'Export payload has an exact source pin') + payload = (root/row['path']).read_bytes() + need(len(payload) == row['size'] and sha256(payload).hexdigest() == row['sha256'], + 'Authenticated payload: '+row['path']) + yield root/pin['package'], root diff --git a/research/p104-asynchronous-helper-hubs/verify.py b/research/p104-asynchronous-helper-hubs/verify.py new file mode 100644 index 0000000000..29ea98777c --- /dev/null +++ b/research/p104-asynchronous-helper-hubs/verify.py @@ -0,0 +1,177 @@ +"""Check temporal helper splits and the full conditional kappa price. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +NOTICE retains the source, native, caller and compiler credit. +""" +import argparse +from collections import Counter +from contextlib import ExitStack +from copy import deepcopy +from hashlib import sha256 +import gzip +import json +from pathlib import Path +import sys +import tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from sources import sources, load, need +import construct + + +def digest(word): + return sha256(json.dumps(word, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def declared_copy(source, target, edits): + text = source.read_text(encoding='utf-8') + for before, after in json.loads(edits.read_bytes()): + need(text.count(before) == 1, 'Unique declared source edit') + text = text.replace(before, after) + need(text == target.read_text(encoding='utf-8'), 'Only declared source edits: '+target.name) + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid construction accepted') + + +def difference(before, after): + delta = Counter(after) + delta.subtract(before) + return {r: n for r, n in delta.items() if n} + + +def controls(word, plan, L): + step = plan['steps'][-1] + buffer, frame = step['buffer'], step['frame'] + move = step['query_events'][0] + events = { + 'omit_history_collection': ['ADD', buffer, 438, '-1', frame], + 'omit_paid_access_query': ['MOVE', move[1], move[2], frame, move[4]], + 'omit_buffer_clear': ['CLEAR', buffer, frame], + } + reasons = {} + for name, event in events.items(): + need(word['program'].count(event) == 1, 'Unique actual control event: '+name) + bad = deepcopy(word) + bad['program'].remove(event) + reasons[name] = reject(lambda: L.replay(bad)) + clear_index = word['program'].index(['CLEAR', buffer, frame]) + need(word['program'][clear_index-1] == ['ADD', word['public']-1, buffer, '1', frame], + 'Actual final injection immediately before CLEAR') + bad = deepcopy(word) + del bad['program'][clear_index-1] + reasons['omit_continuation_injection'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['initial'][-1] = 3 + reasons['wrong_fresh_input_frame'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['final'][step['pivot']] = 127 + reasons['retain_old_rank_nine_target'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['owned_fields'] -= 1 + reasons['omit_owned_buffer'] = reject(lambda: L.replay(bad)) + return reasons + + +def run(): + with ExitStack() as contexts: + parent, _ = contexts.enter_context(sources()) + cursor = parent + for depth in range(6): + module = load(cursor/'sources.py', 'async_helper_source_'+str(depth)) + cursor, root = contexts.enter_context(module.sources()) + declared_copy(parent/'local.py', HERE/'local.py', HERE/'LOCAL-EDITS.json') + declared_copy(parent/'pricing.py', HERE/'pricing.py', HERE/'PRICING-EDITS.json') + L = load(HERE/'local.py', 'local') + L.ROOT = root + source = L.read(parent/'WORD.json.gz') + plan = L.read(HERE/'PLAN.json') + need(digest(source) == plan['source_canonical_sha256'], 'Exact PR5774 source word') + baseline = L.replay(source) + word, witnesses = deepcopy(source), [] + for step in plan['steps']: + need(digest(word) == step['source_sha256'], 'Exact step input') + word, witness = construct.construct(word, step) + need(digest(word) == step['output_sha256'], 'Exact step output') + witness['local'] = L.replay(word) + witnesses.append(witness) + need(len(witnesses) == 3 and sum(len(s['queries']) for s in plan['steps']) == 4, + 'Three helper splits and four paid access points') + local = L.replay(word) + need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'], + local['peak_owned_fields']) == (770, 25, 27, 13), 'Exact storage inventory') + need(local['public_inputs']+local['owned_fields'] < 1000, 'Retained fixed slot allowance') + need(local['paid'] == {1: 2235, 2: 452, 3: 498, 4: 98, 5: 159, 6: 7, 7: 8}, + 'Exact local paid invoice') + need(local['helpers'] == {1: 26, 2: 5, 3: 4, 4: 105, 5: 8, 7: 7, 8: 22, 9: 385}, + 'Exact independent helper invoice') + paid_delta = difference(baseline['paid'], local['paid']) + target_delta = difference(baseline['helpers'], local['helpers']) + need(paid_delta == {1: 4, 2: -2, 3: 2, 4: 2, 7: -2}, 'Exact paid change') + need(target_delta == {1: 1, 4: 2, 5: 2, 8: 1, 9: -3}, 'Exact target change') + transpose = L.reverse_columns(word) + negative = controls(word, plan, L) + print('PASS temporal identities, all scalar columns, frames, ownership and controls', flush=True) + native = L.native(word) + C = load(root/'research/p104-productive-controller/caller.py', 'async_helper_caller') + caller = C.construct() + need(caller == L.read(root/'research/p104-productive-controller/CONTROLLER.json'), + 'Unchanged complete physical caller') + physical = C.physical(caller, word) + print('PASS exact native maps, phases and full physical caller', flush=True) + P = load(HERE/'pricing.py', 'async_helper_price') + price = P.run(local, native, caller, physical) + need(price['previous_pr5774'] == L.read(parent/'RESULT.json')['complete_cost']['kappa'], + 'Exact predecessor exponent') + negative.update(C.controls(caller)) + bad = deepcopy(local) + bad['paid'][1] -= 1 + negative['omit_paid_query_from_invoice'] = reject(lambda: P.assemble(bad, native, caller, physical)) + bad = deepcopy(local) + bad['helpers'][9] += 1 + negative['invent_helper_credit'] = reject(lambda: P.assemble(bad, native, caller, physical)) + result = { + 'status': 'PASS_P104_ASYNC_HELPER_HUBS_KAPPA_00312265044', + 'source_commit': '7d6ec0cdef31d0c37b7d2563e709979caa0d5eae', + 'canonical_word_sha256': digest(word), 'instructions': len(word['program']), + 'local': local, 'separate_columns': transpose, 'native': native, + 'physical_caller': physical, 'complete_cost': price, + 'delta_paid': paid_delta, 'delta_targets': target_delta, + 'negative_controls': negative, + 'limits': ['The five inherited framework assumptions remain.', + 'This gain is below the requested one percent.', + 'The large uniform word and rounded multiplier are not materialized.', + 'Author checks are not independent human or formal acceptance.', + 'The selected frontier is unchanged.'], + } + return P.encode(result), P.encode(witnesses), word + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix='p104-async-helper-bytecode-') as cache: + sys.pycache_prefix = cache + result, witnesses, word = run() + for name, value in (('RESULT.json', result), ('WITNESS.json', witnesses), ('WORD.json.gz', word)): + path = HERE/name + if args.write: + raw = (json.dumps(value, sort_keys=True, indent=2)+'\n').encode() + path.write_bytes(gzip.compress(raw, mtime=0) if name.endswith('.gz') else raw) + else: + raw = path.read_bytes() + need(json.loads(gzip.decompress(raw) if name.endswith('.gz') else raw) == value, + 'Complete retained output: '+name) + print(result['status']) + + +if __name__ == '__main__': + main()