diff --git a/research/p104-joint-contact/PROOF.md b/research/p104-joint-contact/PROOF.md new file mode 100644 index 0000000000..d1c5fb2211 --- /dev/null +++ b/research/p104-joint-contact/PROOF.md @@ -0,0 +1,161 @@ +# Coupled contacts and complete conditional price + +The endpoint is `kappa = 304153/100000000 = .00304153`, improving Ali +Romman's PR5545 endpoint `.00304117` by `9/25000000 = .00000036`. +Source head: `18968423711fd902aaee1099979497d55603e1dc`. +The selected record is unchanged. All five framework premises remain: +native all-column implementation, owned erasure, uniform compiler, +precision and tape costs, and analytic recovery. This proves an ideal +operator change and a complete conditional price; the enormous uniform +word and rounded integer multiplier are not materialized. + +## Literal change and all-width implication + +`construct.py` pins these six zero-based source events: + +| Event | Unchanged scalar operation | Old frame | New frame | +| --- | --- | --- | --- | +| 10461 | `297 += 303` | 335 | 17 | +| 10462 | `303 -= 297/2` | 335 | 17 | +| 13970 | `152 -= 297/2` | 335 | 17 | +| 15479 | `198 += 319` | 915 | 207 | +| 15639 | `205 += 198` | 915 | 207 | +| 15640 | `198 -= 205/2` | 915 | 207 | + +Frame 335 has dimension two. Frame 17 is `span(145)`, dimension one. +Frame 915 has dimension seven. Frame 207 has dimension eight and basis +`[2,5,8,17,33,65,129,257]`. All are existing source canonical charts. +No new coordinate transformation is granted for free. + +The emitter issues every nested MOVE needed to place both operands at +the declared common frame. SCALE occurs at its operand's current frame; +terminal public MOVEs finish at the original exits. Fifteen SCALE chart +annotations change; every scalar coefficient and its order is retained. +INIT/COPY/CLEAR lifetimes are unchanged. Every actual intervening source +read and write is included in the complete replay. The word has 25,310 events. + +The separate [peer proof](peer/PROOF.md) and +[role histories](peer/RECEIPT.json) bind the actual field versions. In the +first group, role 297 coalesces two rank-one rises into rank two; role 303 +splits rank two into two rank-one rises; role 152 replaces two rank-two +rises by ranks one and three. Their net delta is `H1 - 2H2 + H3`. +In the second group, role 198 replaces ranks four plus one by rank five; +role 319 exchanges the order of ranks one and two with zero profile delta; +role 205 splits rank two into two rank-one rises. The net delta is +`H1 - H2 - H4 + H5`. + +Let Phi_F be the exact canonical source chart. At field width f, a role +stores Phi_F tensor-power f applied to its logical value. A MOVE F to G +applies `Phi_G Phi_F^{-1}` tensor-power f, preserving that logical value. +Same-chart ADD/COPY acts on logical values with its scalar applied once, +outside tensor powers. SCALE commutes with transport by linearity. Thus +the unchanged scalar/owned word and fixed endpoint charts imply exactly +the same complete physical operator at every positive f. This is a +compositional induction: no sum is tensor-powered and no width-one +linear-independence claim is used. + +Three exact endpoint checks cover all 743 rows and 552,049 coefficients: +sparse rational forward rows, dense integer reverse columns with binary +denominators, and an independently written integer/dyadic peer interpreter +that imports neither constructor nor native checker. All 735 public inputs +remain arbitrary. All 527 productive helpers retain their targets. Eight +owned lifetimes retain peak occupancy one and the original erasure premise. + +The source native compiler freshly lowers every MOVE, helper boundary and +main adapter. Its separate Gaussian interpreter compares every signed Pauli +image and absolute global phase: 2,979 distinct maps, 1,054 helper normalizers +and 208 main adapters. Wrong phase is rejected. These exact base identities +tensor to every positive f. The unchanged complete caller is freshly checked +through its Laurent identity, 265-axis phase polynomial, 104 ports, both +orientations and actual orthogonal routes. This algebraic check is distinct +from materializing exponential-size all-column matrices. + +The added independent dense audit checks all 512 columns of each of the +four new MOVE maps: `17 -> 720` (rank 2), `17 -> 782` (rank 3), +`615 -> 207` (rank 5), and `775 -> 207` (rank 2). It compares +1,048,576 exact complex entries, including +absolute phase, column norm and support. The unchanged credited PR5548 +arithmetic engine executes the literal source charts and lowered recipes; +the source/vendor tableau is not used for matrix equality. Phase-only +faults invisible to signed Pauli images are rejected. The exact base +equalities tensor factorwise, with phase i^theta lifted as i^(f theta). +This checks the new map interfaces only, and retains the old native and +uniform implementation premises. + +## Complete moment and transfer + +The new local paid profile is + +```text +{1:2430, 2:554, 3:390, 4:111, 5:108, 6:17, 7:13, 9:1}. +``` + +Its delta from PR5545 is + +```text +local: +2H1 -3H2 +H3 -H4 +H5 +complete: +36H1 -54H2 +18H3 -18H4 +18H5 +target: zero at every rank. +``` + +For `H_r=r^t`, `0 H6` edit +and lies outside PR5548's narrow repetition ceiling. + +Each invocation retains helper targets `{4:51,5:36,7:24,8:122,9:294}`. +The full bill includes 18 forward invocations, 15 genuine queries, 15 whole +idles and 32 main banks: 69,912 paid calls, 12,814 productive fields and rank +surplus 760. Maximum paid/target ranks remain 72/145. No helper is omitted. + +`pricing.py` retains PR5544/5545's funding argument. New mathematical +parameters are claimed/tested saving and comparison endpoint; its input +histogram comes from the freshly replayed word. Two independent full +invoice counts and both inherited rational moment engines must agree. +The strict raw crossing enclosure is + +```text +.00304153116714 < raw crossing < .00304153116715. +``` + +The separate funding peer implements a third rational interval engine: +50-term atanh logarithms with rigorous tails and 128-bit outward grids, +followed by alternating exponential bounds of degrees 15/14. It imports +neither retained moment engine. Its four sign enclosures and full invoice +recount agree. The wrapper binds the audited word, source and complete +receipt to this publication. + +Tested saving is `.0030415305`. Cutoff 17, floor 18, tail offset 1/5, +power 1024, reserve `10^-10` and logarithm power 1000 fund completion, +splitting and rounding. Compiler gap is `1/14000000000`, integer height +`H=690116000000000`, test exponent 49,294; the preceding integer point +fails. Ordinary/admitted BIT stock checks and all 54 strict plus four +functional outer predicates pass. `RESULT.json` records exact rationals. +The endpoint gain is not claimed to equal the raw-crossing difference, +which has different safety margins. No global optimum is claimed. + +Scalar coefficients and counts are unchanged. The 26,000-event bound, +per-event scalar growth below `2^16`, total local Gaussian rank 5,894 and +owned peak one still bound reordered prefixes. Local native ranks stay +at most nine. Routing, normalization, COPY, caller and erasure allowances +are recomputed; no precision/tape cost is set to zero. The same five +framework premises remain necessary. + +## Controls, source retention and credit + +The verifier rejects an old-chart contact, wrong butterfly coefficient, +changed source event and uncharged recursive call. The peer also rejects +missing owned CLEAR. Inherited checks reject missing central translation, +wrong native phase, adverse completion cutoff and inadequate BIT saving. +All 33 dependency files are authenticated before imports. The closed +official export retains the exact PR5545 bytes and source attribution. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance, Apache-2.0. +These are author-side checks, not independent human/proof-kernel acceptance. +Credit Ali Romman for PR5544/5545's caller and price; Gareth Davidson for +PR2305; David Arias for PR2152; Cinna Davis for PR2219/controller; Jacob +Alan Sussman for productive recursion; zxv for compiler/outer machinery; +Cao Yifan for pricing; and all geometry, common-chart, dual-ADD, native, +COPY, precision and analytic predecessors in the retained proofs. The +new contribution is this coupled literal itinerary and conditional gain. diff --git a/research/p104-joint-contact/README.md b/research/p104-joint-contact/README.md new file mode 100644 index 0000000000..7b0420abcb --- /dev/null +++ b/research/p104-joint-contact/README.md @@ -0,0 +1,120 @@ +# Conditional kappa .00304153 from coupled P104 contacts + +This contribution increases complete conditional kappa from **.00304117 in +[PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545)** to +**.00304153**, a gain of **.00000036**. Six ADD contacts change frame while +every scalar coefficient and its order remain identical. The selected record +remains .003027288235 and is not edited. + +The first three contacts involve registers 297, 303 and 152; the other three +involve 198, 319 and 205. The exact source events and replacement frames are +listed in [construct.py](construct.py). Their joint local paid delta is + +```text +2 H1 - 3 H2 + H3 - H4 + H5. +``` + +Each of the 18 local calls uses this change. The complete bill still has +**69,912 paid calls and 12,814 productive fields**, with rank-mass surplus +760 and maximum child/target ranks 72/145. Its distribution changes enough +to reduce the concave moment. All 735 independent public inputs, 743 endpoint +rows, productive targets and eight owned lifetimes are retained; peak owned +occupancy remains one. + +These are **author-checked conditional results**. The claim is tested at +.0030415305, with raw crossing in +(.00304153116714, .00304153116715). The five inherited premises remain: +native all-column implementation, owned erasure, the uniform compiler, +precision and tape costs, and analytic recovery. The enormous uniform word +and complete rounded multiplier are not materialized. No independent human +or proof-kernel acceptance, merge or selected-frontier update is claimed. + +Read [PROOF.md](PROOF.md), [the full receipt](RESULT.json), +[the emitted word](WORD.json.gz), [the complete pricing code](pricing.py) +and [the source pins](SOURCES.json). No global optimum is claimed. + +## Replay and source closure + +Python 3.12 and the standard library suffice. From the repository root: + +```sh +python3 -B scripts/research_package.py --package research/p104-joint-contact --check-only +python3.12 -B scripts/research_package.py --package research/p104-joint-contact +``` + +[VERIFY.json](VERIFY.json) registers normal and optimized execution of the +same complete verifier, with a 540-second bound per command, plus two +30-second independent funding checks and two 30-second dense native checks. +The verifier +authenticates the retained predecessor, reconstructs the literal replacement, +checks the complete scalar and signed native endpoints, checks the physical +caller and full invoices, and evaluates both rational moment engines, +compiler/stock conditions and all outer predicates. The receipt and +[VALIDATION.md](VALIDATION.md) distinguish the checks actually executed from +the inherited premises. Metadata validation alone is not scientific replay. + +The separately written [funding audit](funding-peer/README.md) implements +a third rational log/exp interval engine, without importing either source +moment engine. It independently recounts the complete invoice and ordinary +allowances and proves the signs at the claimed/tested savings and both raw +crossing endpoints. [funding_review.py](funding_review.py) binds that audit +to this publication's exact receipt, source capsule, pricing code and word. + +The [four-map dense audit](native-peer/README.md) reuses Chris R/Clear1nsight's +credited PR5548 arithmetic interpreter to compare every complex entry in +all 512 columns of each newly introduced MOVE map. It checks absolute phase, +norm and support rank, totaling 1,048,576 entries per mode. +[native_review.py](native_review.py) binds it to the actual published word +and authenticated native sources and rejects two actual corrupted source +files before import. This covers the four new interfaces, preserving the +inherited old-map and framework premises. The conditional endpoint is unchanged. + +The source is Ali Romman's PR5545 at +`18968423711fd902aaee1099979497d55603e1dc`. Its **unchanged official source +export** is retained as +[inputs/pr5545-source-closure.tar.gz](inputs/pr5545-source-closure.tar.gz). +The custom verifier checks the compressed capsule, embedded export manifest +and all 33 payload files before importing source modules. This capsule is a +dependency: its proof and embedded attribution remain unchanged, and all +source-specific notices continue to apply. Those 33 files are not newly +authored contributions. No foreign-history Git pin is used. The generic +package metadata pins canonical main +`32890bc5de034ab8fc93ac88ead7279a6a416d04` and its revision-7 task card as +historical provenance. The package-local capsule participates in ordinary +package-change invalidation. + +## Open next questions + +Independent review should check the six source sites, their complete frame +paths and source-read intervals, then replay the arbitrary-input native +identity and both complete moment engines. This matters because the result +still depends on the inherited framework premises. No technical source +dependency is missing; independent scientific acceptance remains pending. +The structured handoff is in [TASK.json](TASK.json). + +A later improvement must change a paid path or a productive target contract +and fund the entire caller. Refining the digits of this fixed crossing does +not supply a further structural gain. + +## Credit + +Ali Romman's [PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545) +supplies the starting contact word; his +[PR5544](https://github.com/CrocSwap/integer-mult-bounds/pull/5544) supplies +the productive caller, scalar interpreters and complete pricing engine. +Gareth Davidson (@bitplane) supplied +[PR2305](https://github.com/CrocSwap/integer-mult-bounds/pull/2305), joining +David Arias's (@DavidAriasC) +[PR2152](https://github.com/CrocSwap/integer-mult-bounds/pull/2152) coalesced +word and Cinna Davis's (@1337isnot1337) +[PR2219](https://github.com/CrocSwap/integer-mult-bounds/pull/2219) private +reuse. The general common-chart two-operand transport identity is inherited; +the contribution here is this coupled source-pinned itinerary and its +complete conditional cost gain. + +Retain Jacob Alan Sussman's productive recursion, Cinna Davis's controller, +zxv's compiler and outer machinery, Cao Yifan's pricing lineage, and every +geometry, scalar, native, COPY, precision and analytic author named in the +retained source proofs and notices. Prepared for thu-nmrc with substantial +OpenAI Codex assistance, including parallel subagents. These are author-side +checks. New work is Apache-2.0. diff --git a/research/p104-joint-contact/RESULT.json b/research/p104-joint-contact/RESULT.json new file mode 100644 index 0000000000..a83db6d025 --- /dev/null +++ b/research/p104-joint-contact/RESULT.json @@ -0,0 +1,332 @@ +{ + "complete_cost": { + "compiler": { + "H": 690116000000000, + "N": "2^690116000000000", + "eta": { + "lower": "0.000000184942858502899385581767", + "upper": "0.000000184942858502899385581768" + }, + "gap": "1/14000000000", + "integer_test_exponent": 49294, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "21290713/7000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "9/25000000", + "kappa": "304153/100000000", + "kappa_decimal": ".00304153", + "margin_at_previous": { + "lower": "0.089671185966380263298820901941", + "upper": "0.089671185966380263298820901942" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_routes": 5334000, + "local_scalar": 217428, + "peak_owned_fields": 1, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "3485999999253/3500000000000", + "fixed_halo_explicit_metadata_branch": "269500000001/3500000000", + "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000", + "new_semantic_group_guard": "3/14000000000" + }, + "margins": { + "boundary_algebraic_matrix": "596139935957418577/196000000000000000000", + "fused_gaussian": "596139935872255731/196000000000000000000", + "global_coordinate_router": "2661339/875000000", + "group_bit_router": "37258746867015983/12250000000000000000", + "group_scans": "6999999999/7000000000", + "main_transform": "596139921957418577/196000000000000000000", + "microbox_face_corrections": "269500000001/3500000000", + "polynomial_products": "13999999999/14000000000", + "sparse_union_movement": "80221139935957418577/196000000000000000000" + }, + "parameters": { + "a": "2661339/875000000", + "b": "1703257/560000000", + "beta": "13999999997/14000000000", + "bit_saving": "17/5000", + "cap_xi": "178221139921957418577/196000000000000000000", + "complex_uniform_saving": "21290713/7000000000", + "d": "1/14000000000", + "epsilon": "13999999999/14000000000", + "kappa": "304153/100000000", + "lambda_": "3987833879/4000000000", + "lambda_prime": "13957418577/14000000000", + "layout": "1/14000000000", + "q": "42581423/14000000000", + "r0": "1/140000000000", + "stop": "1/14000000000", + "tested_saving": "6083061/2000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "313661/875000000", + "actual_logarithmic_gamma_guard": "1/14000000000", + "actual_logarithmic_group_guard": "17778860099042581423/98000000000000000000", + "alpha_logarithm_absorption": "1/140000000000", + "boundary_algebraic_matrix_above_kappa": "55957418577/196000000000000000000", + "cap_above_band": "80221139921957418577/196000000000000000000", + "cap_below_cell": "17778860064042581423/196000000000000000000", + "cap_below_phase_cell_power": "213778860078042581423/196000000000000000000", + "complex_above_effective": "1/14000000000", + "complex_below_one_over_32": "15796743/560000000", + "complex_endpoint": "1/7000000000", + "epsilon_below_one": "1/14000000000", + "epsilon_positive": "13999999999/14000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "55872255731/196000000000000000000", + "gaussian_above_main": "6957418577/98000000000000000000", + "global_coordinate_router_above_kappa": "1/3500000000", + "global_gamma_power_slack": "9/140000000000", + "group_below_dimension": "1/7000000000", + "group_bit_router_above_kappa": "4367015983/12250000000000000000", + "group_gauge_power_slack": "17778860098342581423/98000000000000000000", + "group_key_fits_record": "1/7000000000", + "group_positive": "13999999997/14000000000", + "group_scans_above_kappa": "6978709289/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "655279790400418148631/500000000000000000000000", + "lambda_above_internal": "1/28000000000", + "lambda_above_sigma": "3/28000000000", + "lambda_above_tau": "1/28000000000", + "lambda_prime_above_lambda": "1/28000000000", + "lambda_prime_above_leaf": "1118296743/7840000000000000000", + "leaf_saving_above_effective": "558296743/7840000000000000000", + "main_transform_above_kappa": "41957418577/196000000000000000000", + "membership_arithmetic_fits_record": "1/14000000000", + "microbox_face_corrections_above_kappa": "134744677323/1750000000", + "microbox_halo_volume": "1106000000003/14000000000", + "new_complex_uniform_saving_above_b": "1/14000000000", + "new_semantic_guard_with_C1_one": "1/14000000000", + "polynomial_products_above_kappa": "13957418579/14000000000", + "positive_layout_slack": "1/14000000000", + "q_below_effective": "1/14000000000", + "q_below_internal": "1/14000000000", + "q_below_leaf": "1118296743/7840000000000000000", + "q_positive": "42581423/14000000000", + "short_record_fallback": "558296743/560000000", + "source_axis_superpolynomial": "1/14000000000", + "sparse_union_movement_above_kappa": "79625000055957418577/196000000000000000000", + "stop_below_one": "13999999999/14000000000", + "stop_positive": "1/14000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/14000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/14000000000", + "union_tag_work_per_visit_fits_record": "3/14000000000" + } + }, + "paid": { + "1": 45300, + "16": 416, + "2": 9972, + "24": 416, + "3": 7020, + "32": 416, + "4": 1998, + "40": 416, + "48": 416, + "5": 1944, + "56": 416, + "6": 306, + "64": 416, + "7": 234, + "72": 208, + "9": 18 + }, + "paid_calls": 69912, + "previous_open_pr5545": "304117/100000000", + "productive_fields": 12814, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_headroom": [ + "58357/50000000000000", + "23343/20000000000000" + ], + "raw_root_interval": [ + "152076558357/50000000000000", + "60830623343/20000000000000" + ], + "relative_gain_percent": "3600/304117", + "strictification": { + "alpha": { + "lower": "0.999999999302190665441264809032", + "upper": "0.999999999302190665441264809033" + }, + "cutoff": 17, + "delta": { + "lower": "0.963355290100190429734309350200", + "upper": "0.963355290100190429734309350201" + }, + "floor": 18, + "gamma": { + "lower": "0.965231303139134897171411452319", + "upper": "0.965231303139134897171411452320" + }, + "normalized_paid_upper": "5242880004882813/5242880536870912", + "power": 1024, + "reserve": "1/10000000000", + "tail_offset": "1/5", + "tested": "6083061/2000000000" + }, + "targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "4": 918, + "41": 416, + "49": 416, + "5": 648, + "57": 416, + "65": 416, + "7": 432, + "73": 208, + "8": 2196, + "9": 5292 + }, + "whole_idle_jobs": 3120 + }, + "complete_paid_delta": { + "1": 36, + "2": -54, + "3": 18, + "4": -18, + "5": 18 + }, + "independent_peer_science_sha256": "357bf2617d364fb951c704b0bba7bb920629494686ab3866fed910fb0f2f57fc", + "limits": [ + "The five framework assumptions retained by PR5544/5545 remain.", + "The uniform compiler word and complete rounded multiplier are not materialized.", + "No independent human or proof-kernel acceptance, selected promotion, or core-contributor status is claimed." + ], + "local": { + "endpoint_coefficients": 552049, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "owned_lifetimes": 8, + "paid": { + "1": 2430, + "2": 554, + "3": 390, + "4": 111, + "5": 108, + "6": 17, + "7": 13, + "9": 1 + }, + "peak_owned_fields": 1, + "public_inputs": 735, + "real_scalar_allowance": 217428 + }, + "local_paid_delta": { + "1": 2, + "2": -3, + "3": 1, + "4": -1, + "5": 1 + }, + "native": { + "distinct_maps": 2979, + "helper_normalizers": 1054, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "f7dac0d38942f0b02ad21c166281aeed704bc133421843f2b0ededaaf654e4a9", + "wrong_phase_rejected": true + }, + "negative_controls": { + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "one_operand_or_contact_left_at_old_chart": "Scalar destination and coefficient", + "stale_source_or_changed_read": "Exact source ADD at 10461", + "uncharged_recursive_call": "Complete field and call counts", + "wrong_butterfly_coefficient": "All 743 public and owned rows" + }, + "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 + ] + }, + "retained_source_files": 33, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 552049, + "columns": 743 + }, + "source_commit": "18968423711fd902aaee1099979497d55603e1dc", + "status": "PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153" +} diff --git a/research/p104-joint-contact/SEARCH.md b/research/p104-joint-contact/SEARCH.md new file mode 100644 index 0000000000..3d5944002a --- /dev/null +++ b/research/p104-joint-contact/SEARCH.md @@ -0,0 +1,26 @@ +# Discovery scope + +The search treats each ADD/COPY as a common-frame vertex. Consecutive +touches on a public field impose increasing-subspace edges; owned fields +impose decreasing-subspace edges. Public endpoint frames are fixed. +SCALE commutes with transport and keeps its scalar chronology. The objective +is the sum of `abs(dim(F)-dim(G))^(1-.00304117)` over actual transport edges. + +Single-vertex relabels and whole equal-frame-component relabels did not +improve this source. A coupled expansion to one proposed frame allows an +arbitrary subset of vertices to move together. For each edge this is a +binary submodular cost: finite costs satisfy the triangle inequality for +the rank-distance power; illegal subspace orders are forbidden. A minimum +cut proposes the subset. The first sweep found the two changes retained +here; a second sweep over this fixed candidate list found no further gain. + +The candidate list contained the 1,027 source frames and 96 additional +join/intersection extrema of equal-frame components. Both successful moves +use original frames17 and207. No new general optimization algorithm, +global optimum or barrier to other frame/scalar/caller changes is claimed. +Floating arithmetic selected candidates only. The submitted witness is +reconstructed directly from six exact source sites, then checked with exact +scalar/native/phase arithmetic and three rational moment engines. + +The reusable result here is the explicit changed itinerary and complete +conditional price, not an assertion that this bounded search exhausts P104. diff --git a/research/p104-joint-contact/SOURCES.json b/research/p104-joint-contact/SOURCES.json new file mode 100644 index 0000000000..8d83feec6e --- /dev/null +++ b/research/p104-joint-contact/SOURCES.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ], + "retained_source": { + "path": "research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz", + "sha256": "59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837", + "export_manifest_sha256": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "commit": "18968423711fd902aaee1099979497d55603e1dc", + "files": 33, + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5545" + }, + "retained_source_scope": "Exact predecessor export used as a byte-authenticated source dependency. The custom verifier checks the capsule, embedded export manifest and all 33 payload files. This is not a foreign-history Git pin or a claim that the predecessor is newly authored here." +} diff --git a/research/p104-joint-contact/TASK.json b/research/p104-joint-contact/TASK.json new file mode 100644 index 0000000000..db403c85c6 --- /dev/null +++ b/research/p104-joint-contact/TASK.json @@ -0,0 +1,106 @@ +{ + "schema_version": 1, + "task_id": "scalar-to-moment", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "scalar-to-moment", + "question": "Can a changed frame itinerary remove a paid transition beyond the already covered scalar A2 contractions?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-a2-graph-rewrite/README.md", + "research/staged544-separated-a2/README.md", + "research/staged544-a2-composition-audit/README.md", + "research/staged544-a1858-contraction-audit/README.md" + ], + "methods": [ + "Derive the changed legal frame itinerary and exact child histogram.", + "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract." + ], + "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the A2 and separated-A2 constructions and their composition/contraction audits. Scalar contractions can preserve the complete recursive histogram; fewer ADDs alone do not justify further scans.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Identify an actual paid transition to remove and construct a legal replacement frame itinerary, charging restoration, source windows and changed helpers. Compare complete before/after histograms. Stop if only scalar count changes; report that benefit honestly, without expanding the same scalar-only census.", + "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.", + "allowed_variations": [ + "One existing scalar simplification and one proposed frame-path change." + ], + "scope_change_triggers": [ + "Submitting only another scalar count as completion of a paid-profile task." + ], + "overlap_terms": [ + "scalar simplification", + "paid profile", + "R439", + "3998", + "4019", + "4112", + "4152", + "staged544-a2-graph-rewrite", + "staged544-separated-a2", + "staged544-a2-composition-audit", + "staged544-a1858-contraction-audit" + ], + "existing_checks": [ + { + "scope": "PR #3998: consecutive A2 scalar contraction", + "evidence": "research/staged544-a2-graph-rewrite/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4019: separated A2 sites with unchanged recursive histogram", + "evidence": "research/staged544-separated-a2/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "f408e09df300b575235f7f77f81948071397e16d", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4112: composition audit", + "evidence": "research/staged544-a2-composition-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4152: A1858 contraction audit", + "evidence": "research/staged544-a1858-contraction-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Retime six ADD contacts of the pinned PR5545 P104 word and certify the changed complete recursive paid moment, with every scalar coefficient, public endpoint, productive target and owned lifetime retained.", + "scope_change_reason": "The donor requires an original frontier improvement. A released P104 productive caller and PR5545 contact word supply the new source. This task keeps the scalar word and changes the actual paid frame itinerary; the predecessor is retained as an authenticated capsule rather than rerolled or copied into this contribution.", + "bottleneck_link": "The local paid delta 2H1 - 3H2 + H3 - H4 + H5 at each of 18 calls reduces the complete concave moment while preserving total rank mass, paid call count and productive targets.", + "budget_minutes": null, + "stop_rule": "Retain a new conditional kappa only after exact arbitrary-input scalar and native replay, complete paid and productive invoices, both rational moment engines and all inherited outer predicates pass.", + "outcome": "completed", + "evidence": "Author-side source reconstruction, both exact scalar interpreters, signed native maps and full physical caller checks pass. pricing.py checks the complete conditional claim .00304153 at .0030415305; RESULT.json and VALIDATION.md record the final registered replay evidence.", + "author": "thu-nmrc, with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance, including parallel subagents for exploration, source review and publication scaffolding. These are author-side checks, not independent human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Can independent review accept the six contact changes and complete conditional cost join?", + "why_it_matters": "The new paid itinerary improves the conditional caller while the five inherited framework premises and supplier sources remain. Author-side exact checks do not settle their independent scientific acceptance.", + "first_step": "Compare the six pinned source ADD sites in construct.py, replay both exact scalar endpoints and signed native maps, then recompute the before/after paid histograms and both rational moment engines.", + "blocked_by": "No technical source dependency is missing; independent human or proof-kernel review remains pending." + } + ] +} diff --git a/research/p104-joint-contact/VALIDATION.md b/research/p104-joint-contact/VALIDATION.md new file mode 100644 index 0000000000..558f5dae13 --- /dev/null +++ b/research/p104-joint-contact/VALIDATION.md @@ -0,0 +1,110 @@ +# Validation scope and reproduction + +Environment: macOS arm 64, CPython 3.12.13, standard library. Author-side +checks include parallel Codex agents; they are not independent human or +proof-kernel acceptance. No selected record or frozen predecessor is edited. + +## Completed scientific checks + +1. The exact official 33-file PR5545 export was checked and its full original + verifier replayed before searching the successor. It reproduced + `PASS_P104_CONTACT_COMPLETE_KAPPA_00304117`. +2. The successor passed sparse exact forward rows and dense exact reverse + columns, all 743 rows/552,049 coefficients, all 527 helpers, all 735 arbitrary + public inputs, eight owned lifetimes and peak one. Scalar coefficients + and order are exactly unchanged. +3. A separate peer implementation, importing neither constructor nor native + checker, passed normal and optimized read-only execution. It confirms + six ADD and fifteen SCALE chart edits, both new contact invoices and + three real endpoint/chart/owned mutants. Its complete receipt and fixed + inputs are retained under `peer/`. +4. Fresh native lowering and the separate Gaussian/absolute-phase interpreter + passed 2,979 maps, 1,054 helper normalizers and 208 main adapters. The source + phase mutant is rejected. Fresh caller construction and 265-axis physical + checking passed with all 104 ports, both orientations and the exact + retained controller. +5. Both full invoice counts, both rational moment engines, strictification, + compiler grid with rejected predecessor, ordinary/admitted BIT stock and + all 58 outer predicates passed. Complete paid/target counts are 69,912/12,814. + The raw crossing lies in (.00304153116714, .00304153116715); tested saving + is .0030415305; claimed conditional saving is .00304153. +6. The complete publication verifier ran with `--write`, regenerating WORD + and RESULT and repeating the actual source reconstruction, peer, native, + caller, price and semantic controls. It emitted + `PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153`. + +## Registered and cold replay + +The registered normal/optimized pair is run with + +```sh +python3.12 -B scripts/research_package.py --package research/p104-joint-contact +``` + +The complete verifier passed in normal and optimized modes, comparing all +saved semantic artifacts and executing every listed native/caller/price +and semantic control. The final manifest retains these exact argument +arrays with a 540-second bound each and adds normal/optimized 30-second +funding-review commands. Those two new commands also passed. They use +an independently written third rational interval engine and bind its +audited outputs to this publication. Their science digest is +`611b766fc6bfe599b9ae56d5e78b90f6608b5ed3a14baf1d119ca630a5829c9c`. + +Every complete replay compares all saved semantic +artifacts. Compression streams are not mathematical equality checks; +retained immutable source/peer inputs keep their exact byte hashes. +Committed-byte/source-history preflight passed at scientific commit +`5109e17d3f8b7cdc54c01362098d06d622e2fc96`: all43 package files, +canonical source ancestor`32890bc5de034ab8fc93ac88ead7279a6a416d04`. +The official committed export and its integrity checker both passed. + +That exact export was relocated to a new directory with spaces, without +Git. Every file was set read-only(0444), PATH was empty and the interpreter +was absolute, isolated and bytecode-write-disabled. All four commands +passed: full normal169.510s, full optimized99.029s, independent funding +normal0.191s and optimized0.150s. All44 exported files including the export +manifest remained byte-identical, with no new runtime files. The normal +and optimized full logs have the same SHA256: +`219d7d9082668896579616e33d4ea65ff4a33d8c3e282f32ae2d2ece100bcde1`. +The two funding logs also match: +`13f7b14d9cdffeebe73b1c8a62dd9d8654df1fd1ab9a9bb1834b7c71164e8c06`. +This paragraph records that completed run; its addition changes only this +documentation, with every scientific code/input/output byte retained. + +The scientific core at publication head +`79072da5404a01056df2af2e4132324b01c72366` also passed hosted run +40194668767: plan in 3m55s and full registered replay in 8m18s, with committed +inputs unchanged. This is a historical exact-head result, not a claim about +later heads or scientific adoption. + +The subsequent verification-only appendix leaves WORD, RESULT, pricing, +source capsule and complete construction code unchanged. Its four-map +dense audit passed normal/optimized read-only replay in 2.23/2.15s. Each mode +checks all 2,048 columns and 1,048,576 complex entries, phase/sign/boundary/rank +controls and source pins. The parent wrapper additionally binds it to this +publication and checks two actual temporary source corruptions before +import. It registers two extra 30-second commands; all six declared command +timeouts total 1,200s. The source arithmetic interpreter is credited +unchanged reuse from PR5548, not a newly authored independent engine. + +The bound native wrapper at scientific appendix commit +`b8581ee21af9b4bde69112ad6f5b921bb9f34c68` also passed an official-export +cold replay: new path with spaces, files0444, no Git, empty PATH, absolute +isolated Python. Normal/optimized runs took2.286/2.203s and produced +identical stdout SHA256 +`754f8bd5d5d3bc31acbea201f5705cdfcab9da3693e05d24afd5019b52d24e68`. +All69 exported files including the manifest remained byte-identical. +The wrapper makes only its own temporary mutation copies writable. +Of the previous43 files, only README, PROOF, VALIDATION and VERIFY changed; +all earlier scientific code, inputs and outputs stayed exact. This final +paragraph is a documentation-only record of that completed cold run. + +## Limits + +All five framework premises in PROOF.md remain. Native algebra is checked +without materializing exponential-size matrices. The uniform compiler word, +rounded integer multiplier and machine tape are not materialized. A passing +certificate, package runner or CI job does not establish scientific adoption, +selected promotion, a complete multiplication theorem or contributor status. + +Retain the predecessor and new-work attribution in README.md/PROOF.md. diff --git a/research/p104-joint-contact/VERIFY.json b/research/p104-joint-contact/VERIFY.json new file mode 100644 index 0000000000..38d16ae996 --- /dev/null +++ b/research/p104-joint-contact/VERIFY.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 540, + "checks": "Authenticate the retained PR5545 source capsule and its 33 payload files; reconstruct the six exact ADD contact changes; replay the complete arbitrary-input scalar and signed native endpoints, owned lifetimes, physical caller, full paid/productive invoice, both rational moment engines, compiler, stock and all outer predicates. Check the explicit failure controls implemented in verify.py. Passing these checks is conditional author-side evidence." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 540, + "checks": "Authenticate the retained PR5545 source capsule and its 33 payload files; reconstruct the six exact ADD contact changes; replay the complete arbitrary-input scalar and signed native endpoints, owned lifetimes, physical caller, full paid/productive invoice, both rational moment engines, compiler, stock and all outer predicates. Check the explicit failure controls implemented in verify.py. Passing these checks is conditional author-side evidence." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/funding_review.py" + ], + "timeout_seconds": 30, + "checks": "A separately written rational log/exp interval engine proves claimed/tested and both raw-crossing endpoint signs; recount all paid/target jobs and ordinary stock, authenticate the source capsule, compare executable funding logic, and bind every reviewed output to this publication. No native/outer framework is independently reimplemented." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/funding_review.py" + ], + "timeout_seconds": 30, + "checks": "A separately written rational log/exp interval engine proves claimed/tested and both raw-crossing endpoint signs; recount all paid/target jobs and ordinary stock, authenticate the source capsule, compare executable funding logic, and bind every reviewed output to this publication. No native/outer framework is independently reimplemented." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/native_review.py" + ], + "timeout_seconds": 30, + "checks": "Reuse the credited PR5548 dense interpreter to compare all512columns of the four actual added native maps, including absolute phase, exact norm and measured rank; verify all signed-phase/sign/boundary/rank controls, mutate two actual source files before import, and bind the audit to this publication. Old paid-map and framework foundations remain inherited." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/native_review.py" + ], + "timeout_seconds": 30, + "checks": "Reuse the credited PR5548 dense interpreter to compare all512columns of the four actual added native maps, including absolute phase, exact norm and measured rank; verify all signed-phase/sign/boundary/rank controls, mutate two actual source files before import, and bind the audit to this publication. Old paid-map and framework foundations remain inherited." + } + ] +} diff --git a/research/p104-joint-contact/WORD.json.gz b/research/p104-joint-contact/WORD.json.gz new file mode 100644 index 0000000000..c04a815c26 Binary files /dev/null and b/research/p104-joint-contact/WORD.json.gz differ diff --git a/research/p104-joint-contact/common.py b/research/p104-joint-contact/common.py new file mode 100644 index 0000000000..4e3e9f8a04 --- /dev/null +++ b/research/p104-joint-contact/common.py @@ -0,0 +1,47 @@ +"""Authenticate and open the retained Git-free PR5545 source closure. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0. +""" +from contextlib import contextmanager +from hashlib import sha256 +from io import BytesIO +from pathlib import Path,PurePosixPath +import gzip,importlib.util,json,sys,tarfile,tempfile + +HERE=Path(__file__).resolve().parent +def need(ok,why): + if not ok: + raise ValueError(why) + +@contextmanager +def supplier(): + pins=json.loads((HERE/'SOURCES.json').read_bytes())['retained_source'] + path=HERE/'inputs'/Path(pins['path']).name + raw=path.read_bytes() + need(sha256(raw).hexdigest()==pins['sha256'],'Retained PR5545 capsule byte pin') + with tempfile.TemporaryDirectory(prefix='p104-joint-contact-')as tmp: + root=Path(tmp) + with tarfile.open(fileobj=BytesIO(gzip.decompress(raw)),mode='r:')as archive: + members=archive.getmembers() + names=[m.name for m in members] + need(len(names)==len(set(names)),'Unique retained source paths') + for member in members: + name=PurePosixPath(member.name) + need(member.isfile()and not name.is_absolute()and '..'not in name.parts,'Regular retained source path') + target=root/member.name;target.parent.mkdir(parents=True,exist_ok=True) + target.write_bytes(archive.extractfile(member).read()) + manifest_raw=(root/'.research-export.json').read_bytes() + need(sha256(manifest_raw).hexdigest()==pins['export_manifest_sha256'],'Exact official export inventory') + manifest=json.loads(manifest_raw) + need(manifest['commit']==pins['commit']and manifest['package']=='research/p104-full-frame-contact','Exact predecessor head and package') + need(len(manifest['files'])==pins['files']==33,'Full predecessor closure') + need(set(names)=={'.research-export.json'}|{r['path']for r in manifest['files']},'No omitted or extra dependency') + for row in manifest['files']: + raw=(root/row['path']).read_bytes() + need(len(raw)==row['size']and sha256(raw).hexdigest()==row['sha256'],'Source file '+row['path']) + source=root/'research/p104-productive-controller' + spec=importlib.util.spec_from_file_location('local',source/'local.py') + L=importlib.util.module_from_spec(spec);sys.modules['local']=L;spec.loader.exec_module(L) + C=L.load(source/'caller.py','p104_joint_caller') + R=L.load(root/'research/p104-full-frame-contact/construct.py','p104_joint_predecessor') + yield root,L,C,R diff --git a/research/p104-joint-contact/construct.py b/research/p104-joint-contact/construct.py new file mode 100644 index 0000000000..eaf0c11b39 --- /dev/null +++ b/research/p104-joint-contact/construct.py @@ -0,0 +1,66 @@ +"""Six source-pinned ADD contact changes on Ali Romman's PR5545 word. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0. +The P104 supplier and controller retain their predecessor attribution. +""" +from copy import deepcopy + +EDITS = { + 10461: (['ADD',297,303,'1',335],17), + 10462: (['ADD',303,297,'-1/2',335],17), + 13970: (['ADD',152,297,'-1/2',335],17), + 15479: (['ADD',198,319,'1',915],207), + 15639: (['ADD',205,198,'1',915],207), + 15640: (['ADD',198,205,'-1/2',915],207), +} + +def need(ok,why): + if not ok: + raise ValueError(why) + +def span(basis): + out={0} + for v in basis: + need(v not in out,'Independent frame basis') + out|={x^v for x in tuple(out)} + return frozenset(out) + +def construct(source): + need(len(source['program'])==25310 and len(source['frames'])==1027,'Pinned source dimensions') + for i,(expected,_) in EDITS.items(): + need(source['program'][i]==expected,'Exact source ADD at '+str(i)) + frames=[span(b)for b in source['frames']] + current=list(source['initial'])+[None]*8 + out=[] + def move(r,b): + a=current[r] + if a==b: + return + need(a is not None,'Initialized operand') + need(frames[b]=735 else frames[a]=735]);current[r]=b + for i,e in enumerate(source['program']): + op,r=e[:2] + if op=='MOVE': + continue + if op=='INIT': + need(current[r]is None,'Fresh owned lifetime') + out.append(list(e));current[r]=e[2] + elif op=='CLEAR': + need(current[r]==e[2],'Owned chronology unchanged') + out.append(list(e));current[r]=None + elif op=='SCALE': + out.append([*e[:-1],current[r]]) + else: + need(op in ('ADD','COPY'),'Scalar opcode') + f=EDITS[i][1]if i in EDITS else e[-1] + for s in e[1:3]: + move(s,f) + out.append([*e[:-1],f]) + for r,f in enumerate(source['final']): + move(r,f) + word=deepcopy(source);word['program']=out + signature=lambda w:[e[:-1]for e in w['program']if e[0]!='MOVE'] + need(signature(word)==signature(source),'Every scalar/owned coefficient and order retained') + need(len(out)==25310,'Fixed complete word length') + return word diff --git a/research/p104-joint-contact/funding-peer/FILES.sha256 b/research/p104-joint-contact/funding-peer/FILES.sha256 new file mode 100644 index 0000000000..ed83b6696b --- /dev/null +++ b/research/p104-joint-contact/funding-peer/FILES.sha256 @@ -0,0 +1,19 @@ +c594bb9ba4de6c032d666d6dac2a472e953c3a42b563cfc7f90f1ce88a7b14f4 INTERVAL-PROOF.md +157c57aafcb14e4d4bd11e44dfc315b82699a2acc5e3c60abb08556ad28d21e2 README.md +139c9c659a919d5277709d72003760128e6a353cbfda9283ad3d1e11b7d5df4f RECEIPT.json +a127d17925555bd1282c369ce02fa76328ef2376b0d3e96073bdaa54ce4fb0a3 check.py +535106a3caee2bc849b5d14438282ee211bafd31fc3d28e10137647673bbd15c inputs/AUDITED-CANDIDATE-WORD.json.gz +637e562cb4bb66591bd2a1e389f2a97fea36e9ab84a39d482fe7f44f3412f594 inputs/PUBLIC-PROOF.md +23b3f75a1726b4ece1538cd6c8ce3655f2741c672bc58d481ab2bf518387ed70 inputs/PUBLIC-README.md +36a5680f43c7da67e570b6c919de2934c6a5ce46db002993ff162aa36972d0ba inputs/PUBLIC-RESULT.json +48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446 inputs/PUBLIC-WORD.json.gz +7a2fbb32f74cf8555abd632554754e48c04fa6f3e2ec48fa6675b201f95eda11 inputs/SOURCES.json +bbfccffbc14b351606b009239290b36d09d65cc3918721a0bd04f66b0f02f908 inputs/complete_cost.json +a84f6bbd547379597464e56c420cc665f96bc43a9a1351eed4b7cd0fce3cc4b9 inputs/controller.json +cfae881d60a0bc28b457bed68cab1bcb303f3848dffadc286eebb68eaa8c8336 inputs/local-peer-RECEIPT.json +08c7f37adc98c1b073f773eb22cfd3664d14112093636b9255e374833d3bc7a6 inputs/local.json +d40076954a9c811a3e3668e7f24cb674768e92b0080e7d65efb6043a6c1afe49 inputs/native.json +b257eb40480269328821e334de3fef6c64a652ff4f0628411a98be398d4cfea0 inputs/physical.json +59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837 inputs/pr5545-source-closure.tar.gz +f74461d08c1cfdb9d500ac4f0da11f1b2d66a149bb342145b9aab9df703017a9 inputs/predecessor_pricing.py +80e55ca33c4328f406fd09c5bd27df1db03cfd7847ff3c5c3151ede673629290 inputs/successor_pricing.py diff --git a/research/p104-joint-contact/funding-peer/INTERVAL-PROOF.md b/research/p104-joint-contact/funding-peer/INTERVAL-PROOF.md new file mode 100644 index 0000000000..14a4ef27a3 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/INTERVAL-PROOF.md @@ -0,0 +1,22 @@ +# Independent rational moment enclosure + +For an integer rank r >= 1, choose e=floor(log2 r), u=2^e and z=(r-u)/(r+u), so 0 <= z < 1/3. Then + +``` +log r = e log 2 + 2 sum_{j>=0} z^(2j+1)/(2j+1), +log 2 = 2 sum_{j>=0} (1/3)^(2j+1)/(2j+1). +``` + +After N=50 terms, the positive omitted tail is at most + +``` +2 z^(2N+1) / ((2N+1) (1-z^2)). +``` + +The checker evaluates each finite sum and tail exactly with rational arithmetic. It rounds the lower sum down and the sum-plus-tail up on the binary grid 2^-128. Combining these intervals gives rigorous log(r) bounds. This proof does not assume binary floating-point log, exp or fractional power accuracy. + +For each tested saving k, x=k log r lies in [0,1), checked explicitly. The alternating series for exp(-x) has decreasing term magnitudes. Its degree-15 truncation is a lower bound and its degree-14 truncation an upper bound. Since exp(-x) is decreasing, evaluating the lower polynomial at the upper x endpoint and the upper polynomial at the lower x endpoint encloses exp(-x). Multiplying by r encloses r^(1-k). + +Weighted addition gives target and paid moment intervals. Subtracting the upper paid bound from the lower target bound proves each positive margin; the opposite subtraction proves the negative raw-upper margin. All computations use fractions of integers, without floating point. The sign crossing enclosure is not asserted to be the only root. + +The two complete invoice reconstructions are (1) literal LOCAL/QUERY_SHEAR/IDLE events plus the actual diagonal target exponents, and (2) eighteen local profiles, fifteen rank-1 query batches and the length-seven/eight path formulas. They agree with every rank of the public target/paid histograms. The exact separately audited local helper and paid profiles provide the input binding. diff --git a/research/p104-joint-contact/funding-peer/README.md b/research/p104-joint-contact/funding-peer/README.md new file mode 100644 index 0000000000..20e76eeb0d --- /dev/null +++ b/research/p104-joint-contact/funding-peer/README.md @@ -0,0 +1,20 @@ +# Final conditional funding peer review + +No new local algebra, source-closure, ordinary-cost, stock or all-width blocker was found in the P104 joint-contact successor package. This is an AI author-side peer review; it is not independent human or proof-kernel acceptance. + +The six-ADD / fifteen-SCALE retiming was already independently checked on all 743 exact endpoint rows in the separate local peer package. This final review authenticates the complete 33-file predecessor export, binds the public emitted word and receipt to that audited candidate, checks the funding code against the predecessor, recounts the complete invoice in two ways, and proves the decisive moment signs with a newly written rational interval engine. No constructor, native verifier, caller compiler, or predecessor moment engine is imported by `check.py`. + +``` +python3.12 check.py +python3.12 -O check.py +``` + +Default execution is read-only. `--write` is explicit author mode. All inputs are same-folder copies. The receipt binds every input byte. The public PROOF/README copies record the mathematical documentation reviewed; later publication validation-log additions are outside these input snapshots. + +The complete counts are 69,912 paid services and 12,814 productive fields, with rank-mass surplus 760. The local change is `2H1 -3H2 +H3 -H4 +H5` at each of 18 invocations. All 527 helper targets remain. Exact scalar order, scalar allowance 217,428, total local Gaussian rank 5,894, owned peak one and eight owned lifetimes remain unchanged. Recomputed local routing allowance is 5,334,000 and the complete ordinary bound is 184,647,552, below its inherited 10^9 budget. + +The funding-code AST is identical to PR5545's after explicitly replacing the claimed/tested/comparison constants and output labels. This protects the compiler, completion, BIT and outer arguments from accidental weakening. The public receipt is byte-semantically tied to the separately executed native/caller/outer results. Those framework implementations were not independently reimplemented here. + +The fresh rational engine verifies positive margins at `.00304153`, `.0030415305` and `.00304153116714`, and a negative margin at `.00304153116715`. This proves the advertised local sign crossing; it does not prove uniqueness or a global optimum. The complete transfer still has exactly the five inherited premises: native all-column implementation, owned erasure, uniform compiler, precision/tape costs, and analytic recovery. The huge uniform word and rounded multiplier are not materialized. This review does not grant unconditional multiplication complexity, scientific adoption or selected promotion. + +Only two documentation files in the publication package were edited with explicit parent authorization: PROOF.md and VALIDATION.md, to restore corrupted literal SHA, PR/H-rank tokens, PASS markers and the reproducible command. Scientific code, words, receipts and predecessor inputs were not modified by this final review. diff --git a/research/p104-joint-contact/funding-peer/RECEIPT.json b/research/p104-joint-contact/funding-peer/RECEIPT.json new file mode 100644 index 0000000000..8de2c5230c --- /dev/null +++ b/research/p104-joint-contact/funding-peer/RECEIPT.json @@ -0,0 +1,122 @@ +{ + "calls": 69912, + "fields": 12814, + "independent_rational_moment_engine": { + "exponential_bounds": [ + 15, + 14 + ], + "log_atanh_terms": 50, + "log_rounding_bits": 128, + "probes": { + "claimed": { + "interval_width": "30431192217839097909016228877755794942354675824966859451867534490858522764551544813529412965045100560189805485262223244059043158504864540383928754025774257151844361634561529395424937595359202268570037842177751824174859795148047497295097041222461377224504331911253133388170568372440441288048562972036851611789416466940883848019423601787771809728609461474170846965220313622623040232661674203478489019628488699280224500705237905822900666126457955691711620942431271906875305834244787917453580782572568425091256888843085543032119215606610628082178024380075902679713362474536644344174360903623034113934455915600216389211537829915058512549090219925113330581068629901560842191402981/862439807309199209921253026052517516203317655691461242469780966106899697181459325734274663071657353771427712944528329400832331807504832689956371481473080134620888690862859155143408920009478942205027699027930255800613732992494415036130679327745778130462273367693647542216706676059321633107436503408414927743883450571929364822861971479128838722662550412259595019968040662235809227914309016633842584392405254554996453579146537403510414562465032659005202358692122570383889745509821777402881186146539326892114985987970930511751866281463443536151468799339249986815930574793990231198607081472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "kappa": "304153/100000000", + "margin": [ + "93719399901389001874576816551201433076863278063631223708958879049621235477357920469500367559388938020275306141149912352703487861485050733483303713647155650801579342292810239367800364139173465247073827992148768488097269846680810584842063235227986160812485440939348408183486661029160750057749445936283517284353043581577789266100571664994433094193919374818214450606381253331372460746927017442948117111178523240601766246328047204784722622756996741835171261291062264183853201460720535799811942345239164459427134023663046755962147499833187493738321738192442114390232965400039722843262798392531209731385532381903246438795696428285340180537930479664422553615696819605996086093820149447395660917181125499785302439/323414927740949703720469884769694068576244120884297965926167862290087386443047247150352998651871507664285392354198123525312124427814312258733639305552405050482833259073572183178778345003554603326885387135473845925230149872185405638549004747904666798923352512885117828331265003522245612415288688778155597903956293964473511808573239304673314520998456404597348132488015248338428460467865881237690969147151970458123670092179951526316405460924387247126950884509545963893958654566183166526080444804952247584543119745489098941906949855548791326056800799752218745055973965547746336699477655552000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "149951039842222402999322906481940551638311948360555367671660859956359389569267652866871708615716815946099220752727977412104607638712195056864443275781884467177629866392726740240896047176968651012298861705075284543512847276050438958452607827459282773177065534001334511318312134472991902691545865378086529995988333995297291963544136774958166600590435530017954775131282668416033102871967730416896119566059211009102422998646962621067333289630762921636697160809193363093840997110567884252264566515526788318583961310611346958008979540788154744114620632433726654553736711016912863363848522969657763587701573797651698918615288105724904962410048897296603008483063946477123191882067307114181698645430737304971325691/517463884385519525952751815631510509721990593414876745481868579664139818308875595440564797842994412262856627766716997640499399084502899613973822888883848080772533214517715493086045352005687365323016619416758153480368239795496649021678407596647466878277364020616188525330024005635592979864461902045048956646330070343157618893717182887477303233597530247355757011980824397341485536748585409980305550635443152732997872147487922442106248737479019595403121415215273542230333847305893066441728711687923596135268991592782558307051119768878066121690881279603549992089558344876394138719164248883200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "raw_lower": { + "interval_width": "11465294373180421902673290422138611679840371458155442727896202080473742857934242691225663034653725682380151751313408700044655000931035658373074310744543549264871130904769985792518741455699283872485080859726436296123786475650727013719229110216853563537376923167530380943512309218078146581107611916170044132495109641575618565450885798451984964062517510060241272498937425345732910951060432749130889721251245456259567035668926317071531826896468316335344593089266483375735154456705762718780073382614265708851091144834737250460312360588695716462977597343127721813507171941785991175369601569251850785139439085546550749752399930324829414739041671346899981328438704473897566834827873604727967714038242183208433102601990389785139604773536055016741142982926421314954649/324933014786030036048890300252473625353897530145136041512112451664262822349062065118587037290090811937658131142897741774884384271129027073219721846016996457934302319510324418863709596237174683447954229294738865906746469377115288265324601285108694620188874936588860986861883724282091544109367654459791744936298681403992966950164407416121433859992340619973866034601674270530346238092232792845866859112927568056081683718512843531294613897051411441381083305713841029182298352468917951194059088868144217368086821374952878791621405059989060215383070505152290245080992361862367316803584000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "kappa": "152076558357/50000000000000", + "margin": [ + "751707221001821801384360788067128938651025233245110332915495348179125145161406227669073034881741474464265884589228258242504441813369947576985464060396294591848502002899786205756822078317620966787891176813562611212082882460824593141103047639088149991856577447059696851673014487868937513612790144615778058027026090887827523913324793122750268669166497260002509106476740240399057616753517041616310988939781466483812341783098780771779999164579041263095750967977731415831352114453255490664049327632079104924778737262113319929923565907117514649809213546871021748189921434803876386082950398952684188166939871692865893582502142700466128137308637275135967308154152126554241496964624073538412860344204204999666400858032635197308860777133108742466860888462972349180170069369543592719891747301/527488660366931876702743993916353287912171315170675392065117616338088997319905949867836099496900668729964498608600230154033091349235433560421626373404215029114127142062214965687840253631777083519406216387563094004458554183628714716436041047254374383423498273683215887762798253704694065112609828668493092429056300980508063230786375675521808214273280227230302004223497192419393243656222066308225420637869428662470265776806564174179568014693849742501758613171819852568666156605386284405940079331402950272868216517780647388995787435047175674323166404468003644612000587438907981824000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "92610329627424445930553251382929159877890689270455677442911362863742509514973792828070213992179121240846095226525528346221683707437527804166349181171823679922867121372115809457950333022957084062265351487179204841185385616189761820271154693892955209142133085323576695496828092380837735183171934519125700364558930618902734180130441011744761415165025552609468812314927210120665910432287799314614582983963266882892230333855714041332387148989545017398659933561221889724085847569559694303107552311303037067885284186707037538219725089975106771803945201036981997116141613363357039390963851852405080339365227266481391939734421008585244095826574062776737237330474489799816821806037951547673359173919325021533621531303163463956888289429419517469995218486559148126207955894556367208374926258413/64986602957206007209778060050494725070779506029027208302422490332852564469812413023717407458018162387531626228579548354976876854225805414643944369203399291586860463902064883772741919247434936689590845858947773181349293875423057653064920257021738924037774987317772197372376744856418308821873530891958348987259736280798593390032881483224286771998468123994773206920334854106069247618446558569173371822585513611216336743702568706258922779410282288276216661142768205836459670493783590238811817773628843473617364274990575758324281011997812043076614101030458049016198472372473463360716800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "raw_upper": { + "interval_width": "6783483357503033901106892196070069653955256036558990476354181698929524911329793421639922507986675803904662221042113902205426042709412356765580072511530887234965530278429071861414881872470723644452953360702806566515006881855253857013341918193368821904537284954667077568884274236770378617905524157306944055293899103566441593229182785676724268448374238728884284637823211813915812289015315718323264725589106096259081120121279516448360682064312945851820550288244372557461745617119140346697278730834126636303519536732047887931918288652413884653412566404708933615779323164934938221835088945180749760518296500979071290943139757110645782626474245391328344704772407568029356960811945695047238594224052022905791499395370746578104190612749669370088858987162464673/192247806842910474222446388827815605244559951984338789069726412907421015491442579494290558908381416111443151685485063250384175841281077262479526399353128502389505310355062372760130772046738816178056786678552507633159937433320115591183197960622950052918284174915547229002428873204842525671186934310795512600758999376469261404867626404272746852137458856523281698056549363402333311430585563653454107519526091028966828509397780528151219485597647552178792318977030424396865980822216598652636807535032657575515808577236948646320307172183633454371505643651350636516900769216663074121877257453568000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "kappa": "60830623343/20000000000000", + "margin": [ + "-228768212794916974668030564285266636795884919836420990172416511439779675921494918248030895148365968054472704668059764641132108648400431568843267921187950771764326266717790701101817027524717660539999034576582401080586027108996509451499313308026759896217710556271116565421153861636709703923549749874807191743276141802724494822770454326132176229693764990584236428201982975276052871718687371211053786019756771549106889704812953116847225312950542999161712502706163266253657453571698611789829896698170529912640933448845793140261969196332601744777530374238241335674568983820052690685270179442783638248865295688995302197394980138975080177404567044169718581557043044641365769941459904102670953143941096099933172166701190902967366379594519868374123261944133534849038578153053194693559439/216278782698274283500252187431292555900129945982381137703442214520848642427872901931076878771929093125373545646170696156682197821441211920289467199272269565188193474149445169355147118552581168200313885013371571087304929612485130040081097705700818809533069696779990632627732482355447841380085301099644951675853874298527919080476079704806840208654641213588691910313618033827624975359408759110135870959466852407587682073072503094170121921297353496201141358849159227446474228424993673484216408476911739772455284649391567227110345568706587636167943849107769466081513365368745958387111914635264000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-366029140471867159468848890646156575367954849745867631349741041184186615668209011759322374164240708493528168517035109049794926809048692634344204704133844357880679848704334601007310221101593755691669104775744471281635083359078365857347081565830428494491394266018333756609966750451622607876939975807997880602560314654415708563933427392793095547915156172405764067019489553368054882758187445855904792583148714251002730545824218926564587234374852580355610397280633510242549392437727260023857231285930737045772869463051553522991205367796996673957850321328266562734317997969464776620351778705672124315295673799232382190482399289426426521518983573019986931328860143772543527515315377973939902577463224298390824381692435841454144976926532877731253378523070552809056858884938934617258691/346046052317238853600403499890068089440207913571809820325507543233357827884596643089723006035086549000597673033873113850691516514305939072463147518835631304301109558639112270968235389684129869120502216021394513739687887379976208064129756329121310095252911514847985012204371971768716546208136481759431922681366198877644670528761727527690944333847425941741907056501788854124199960575054014576217393535146963852140291316916004950672195074075765593921826174158654763914358765479989877574746253563058783635928455439026507563376552909930540217868710158572431145730421384589993533419379063416422400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "tested": { + "interval_width": "12310746708308830303711159775362945455372020494755667999392121547068038286923895380297735037731641762420935523254214139692239866109564099311285326493438099942801654099502711494424284246184990877903775227889969422705890263969110580284496231613041498378297651382595217321002672131720763963701349552926119777719529413407569416918123925040274795982297913390582366137246724048011190813877561349847958971868396510475841117723510999324571916535669103079164723905302736606213715061750519694135694823733681736621193587115005477191811380096514365254560610819455892256297260881255745609804253401424854529183987186608226274450426164732417836635853111883821410048765825975102216317299873876963224164955193/348894167974170860625921224168998690999386579527133357941355341943097398484469866489638421722618125535582016021806225898845356156398992068944325687714936911743917044718446528342459549270007481212028983231447143482401367934543913480295433335945353799740589798920807934115519066186566065106968880786258522868044109979518289216241247918865355398323536443320029748324848844693123417040692319222935232165065868904421281368907083180718879807195730742842993467773129288720238261492170864221451984045059267451862022973504091987766483386555482935711250982922821525530671766356166319702666133897216000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "kappa": "6083061/2000000000", + "margin": [ + "7223851138331919045388865406517423673572952248152883980428360566048016218789623611670280587994863805048411561843346442703901578419234614945753912439288549481884348612072207043623841154028833221896803801856525793228664822599595106917682366645263061143341527784420178502099121614245147223202046112482297170846655332649998346517621520360812249844838566308935370043384820935459214797340296472946286869470084104663802394283073006417974062664583178386018856313610590524322491052810430011152415489764485442345164413976934116682604314997726943443020609104476538822868230744122382456884054659279742891383988126202801340257546440409895849342260982223134491101248038881832653343013906151264866662187888230188935439217943389207778689/43611770996771357578240153021124836374923322440891669742669417742887174810558733311204802715327265691947752002725778237355669519549874008618040710964367113967989630589805816042807443658750935151503622903930892935300170991817989185036929166993169224967573724865100991764439883273320758138371110098282315358505513747439786152030155989858169424790442055415003718540606105586640427130086539902866904020633233613052660171113385397589859975899466342855374183471641161090029782686521358027681498005632408431482752871688011498470810423319435366963906372865352690691333970794520789962833266737152000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "11558161821331070472622184650430340027058385363105356600640449494767900354162348912272327365101195695734843278025413855333788853823259571017857102730800127144236870599177788335096833466434693485854786625269326126015100714334932926113869780516962075882140266571129184849681202882467895087399792823435876007780992685032737624338779656532843505634423219977680216854423768455931203258422590829941508335961736805624859343122886402063132179565428253641174872301641859222223119505112520962624925330944419450764613166301921725656913640343687348226255975662600824392608472063646724053178378633298848078390632151046442995092359275561670156384939216811905270994943345778259415971199014124033539824695641611565756677524102067565436941/69778833594834172125184244833799738199877315905426671588271068388619479696893973297927684344523625107116403204361245179769071231279798413788865137542987382348783408943689305668491909854001496242405796646289428696480273586908782696059086667189070759948117959784161586823103813237313213021393776157251704573608821995903657843248249583773071079664707288664005949664969768938624683408138463844587046433013173780884256273781416636143775961439146148568598693554625857744047652298434172844290396809011853490372404594700818397553296677311096587142250196584564305106134353271233263940533226779443200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + } + } + }, + "inherited_assumptions": [ + "Native implementation at every column", + "Owned erasure", + "Uniform compiler", + "Precision and tape costs", + "Analytic recovery" + ], + "input_pins": { + "AUDITED-CANDIDATE-WORD.json.gz": "535106a3caee2bc849b5d14438282ee211bafd31fc3d28e10137647673bbd15c", + "PUBLIC-PROOF.md": "637e562cb4bb66591bd2a1e389f2a97fea36e9ab84a39d482fe7f44f3412f594", + "PUBLIC-README.md": "23b3f75a1726b4ece1538cd6c8ce3655f2741c672bc58d481ab2bf518387ed70", + "PUBLIC-RESULT.json": "36a5680f43c7da67e570b6c919de2934c6a5ce46db002993ff162aa36972d0ba", + "PUBLIC-WORD.json.gz": "48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446", + "SOURCES.json": "7a2fbb32f74cf8555abd632554754e48c04fa6f3e2ec48fa6675b201f95eda11", + "complete_cost.json": "bbfccffbc14b351606b009239290b36d09d65cc3918721a0bd04f66b0f02f908", + "controller.json": "a84f6bbd547379597464e56c420cc665f96bc43a9a1351eed4b7cd0fce3cc4b9", + "local-peer-RECEIPT.json": "cfae881d60a0bc28b457bed68cab1bcb303f3848dffadc286eebb68eaa8c8336", + "local.json": "08c7f37adc98c1b073f773eb22cfd3664d14112093636b9255e374833d3bc7a6", + "native.json": "d40076954a9c811a3e3668e7f24cb674768e92b0080e7d65efb6043a6c1afe49", + "physical.json": "b257eb40480269328821e334de3fef6c64a652ff4f0628411a98be398d4cfea0", + "pr5545-source-closure.tar.gz": "59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837", + "predecessor_pricing.py": "f74461d08c1cfdb9d500ac4f0da11f1b2d66a149bb342145b9aab9df703017a9", + "successor_pricing.py": "80e55ca33c4328f406fd09c5bd27df1db03cfd7847ff3c5c3151ede673629290" + }, + "ordinary": { + "lifetimes": 8, + "local_rankmass": 5894, + "local_routes": 5334000, + "local_scalars": 217428, + "owned_peak": 1, + "whole_raw": 184647552 + }, + "paid": { + "1": 45300, + "16": 416, + "2": 9972, + "24": 416, + "3": 7020, + "32": 416, + "4": 1998, + "40": 416, + "48": 416, + "5": 1944, + "56": 416, + "6": 306, + "64": 416, + "7": 234, + "72": 208, + "9": 18 + }, + "price_funding_code": "Executable logic unchanged except claimed/tested/comparison values and output labels", + "rank_surplus": 760, + "scope": "Independent source authentication, static funding-code comparison, full histogram recount and fresh rational moment signs. Uses separately executed author native/caller/outer receipts; does not independently implement those frameworks or claim human/proof-kernel admission.", + "source_closure": { + "capsule_sha256": "59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837", + "commit": "18968423711fd902aaee1099979497d55603e1dc", + "export_sha256": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "files": 33 + }, + "status": "PASS_SCOPED_CONDITIONAL_ADMISSION_AUDIT", + "targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "4": 918, + "41": 416, + "49": 416, + "5": 648, + "57": 416, + "65": 416, + "7": 432, + "73": 208, + "8": 2196, + "9": 5292 + } +} diff --git a/research/p104-joint-contact/funding-peer/check.py b/research/p104-joint-contact/funding-peer/check.py new file mode 100644 index 0000000000..fb481670d8 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/check.py @@ -0,0 +1,130 @@ +"""Independent full-invoice recount and rational moment sign sanity proof. + +No import from either pricing engine, native checker, or candidate constructor. +""" +from pathlib import Path,PurePosixPath +from fractions import Fraction as Q +from collections import Counter +from hashlib import sha256 +from io import BytesIO +import argparse,ast,gzip,json,tarfile +ROOT=Path(__file__).resolve().parent;IN=ROOT/'inputs' +def need(ok,why): + if not ok:raise ValueError(why) +def read(n):return json.loads((IN/n).read_bytes()) +def ctr(x):return Counter({int(k):v for k,v in x.items()}) +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,(tuple,list)):return[encode(v)for v in x] + return x +def source_closure(): + pins=read('SOURCES.json')['retained_source'];raw=(IN/'pr5545-source-closure.tar.gz').read_bytes() + need(sha256(raw).hexdigest()==pins['sha256'],'capsule pin') + with tarfile.open(fileobj=BytesIO(gzip.decompress(raw)),mode='r:')as t: + ms=t.getmembers();names=[m.name for m in ms] + need(len(names)==len(set(names))and all(m.isfile()and not PurePosixPath(m.name).is_absolute()and '..'not in PurePosixPath(m.name).parts for m in ms),'regular unique members') + blobs={m.name:t.extractfile(m).read()for m in ms} + manifest=blobs.pop('.research-export.json');need(sha256(manifest).hexdigest()==pins['export_manifest_sha256'],'export pin');m=json.loads(manifest) + need(m['commit']==pins['commit']and len(m['files'])==33==pins['files'],'source head and count') + need(set(blobs)=={x['path']for x in m['files']},'exact source closure') + for x in m['files']:need(len(blobs[x['path']])==x['size']and sha256(blobs[x['path']]).hexdigest()==x['sha256'],'source payload '+x['path']) + return dict(files=33,commit=pins['commit'],capsule_sha256=pins['sha256'],export_sha256=pins['export_manifest_sha256']) +class Funding(ast.NodeTransformer): + def visit_Module(self,n): + n=self.generic_visit(n) + if isinstance(n.body[0],ast.Expr)and isinstance(n.body[0].value,ast.Constant)and isinstance(n.body[0].value.value,str):n.body.pop(0) + return n + def visit_Assign(self,n): + names={x.id for t in n.targets for x in ast.walk(t)if isinstance(x,ast.Name)} + if names in ({'KAPPA','TESTED'},{'PREVIOUS'}):n.value=ast.Constant('CLAIM_PARAMETERS') + return self.generic_visit(n) + def visit_Dict(self,n): + n=self.generic_visit(n) + for i,k in enumerate(n.keys): + if isinstance(k,ast.Constant)and k.value=='kappa_decimal':n.values[i]=ast.Constant('CLAIM_DECIMAL') + if isinstance(k,ast.Constant)and k.value in ('previous_open_pr5544','previous_open_pr5545'):n.keys[i]=ast.Constant('PREVIOUS_PR_LABEL') + return n +def normalized_code(p):return ast.dump(Funding().visit(ast.parse(p.read_text())),include_attributes=False) +# Fresh elementary rational interval engine. Log uses atanh series; exp(-x) +# uses alternating Taylor bounds. Both are unrelated to retained suppliers. +S=1<<128;NLOG=50 + +def qfloor(x):return x.numerator//x.denominator +def qceil(x):return -((-x.numerator)//x.denominator) +def logunit(z): + z=Q(z);s=Q(0);power=z + for k in range(NLOG):s+=2*power/(2*k+1);power*=z*z + rem=2*power/((2*NLOG+1)*(1-z*z)) + return Q(qfloor(s*S),S),Q(qceil((s+rem)*S),S) +LOG2=logunit(Q(1,3)) +def logrank(r): + e=r.bit_length()-1;u=1<0,'independent exact moment sign '+name) + probes[name]=dict(kappa=k,margin=m,interval_width=m[1]-m[0]) + need(sum(ctr(l['paid']).values())==3624 and sum(r*x for r,x in ctr(l['paid']).items())==5894,'unchanged local route and Gaussian mass') + routes=(3624+n['helper_normalizers']+n['main_adapters']+4*104+4*8)*1000 + boundary=sum(len(c['boundaries'][s+'_program'])for s in ('left','right')) + raw=18*10**7+15*1664+32*104*(len(c['physical_events'])+boundary)+32*104*(26+1000) + need(routes==cost['nonrecursive']['local_routes']==5334000 and l['real_scalar_allowance']+routes<10**7,'all local ordinary route allowance') + need(raw==cost['nonrecursive']['raw_scalar_upper']==184647552 and raw<10**9,'complete ordinary allowance') + gap=(Q('.0030415305')-Q('.00304153'))/7 + need(gap==Q(1,14000000000)and cost['compiler']['gap']==str(gap),'integer compiler gap') + need(len(cost['outer']['strict_checks'])==54 and len(cost['outer']['functional_checks'])==4 and all(Q(x)>0 for family in ('strict_checks','functional_checks')for x in cost['outer'][family].values()),'all cached outer conditions positive') + return encode(dict(status='PASS_SCOPED_CONDITIONAL_ADMISSION_AUDIT',input_pins={str(p.relative_to(IN)):sha256(p.read_bytes()).hexdigest()for p in sorted(IN.rglob('*'))if p.is_file()},source_closure=closure,price_funding_code='Executable logic unchanged except claimed/tested/comparison values and output labels',targets=T,paid=P,fields=sum(T.values()),calls=sum(P.values()),rank_surplus=760,independent_rational_moment_engine=dict(log_atanh_terms=NLOG,log_rounding_bits=128,exponential_bounds=[15,14],probes=probes),ordinary=dict(local_routes=routes,local_scalars=l['real_scalar_allowance'],whole_raw=raw,local_rankmass=5894,owned_peak=1,lifetimes=8),inherited_assumptions=['Native implementation at every column','Owned erasure','Uniform compiler','Precision and tape costs','Analytic recovery'],scope='Independent source authentication, static funding-code comparison, full histogram recount and fresh rational moment signs. Uses separately executed author native/caller/outer receipts; does not independently implement those frameworks or claim human/proof-kernel admission.')) +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args();r=json.loads(json.dumps(calculate(),sort_keys=True));p=ROOT/'RECEIPT.json' + if args.write:p.write_text(json.dumps(r,sort_keys=True,indent=2)+'\n') + else:need(read_receipt(p)==r,'frozen review receipt') + print(json.dumps(dict(status=r['status'],science_sha256=sha256(json.dumps(r,sort_keys=True,separators=(',',':')).encode()).hexdigest(),fields=r['fields'],calls=r['calls']),sort_keys=True)) +def read_receipt(p):return json.loads(p.read_bytes()) +if __name__=='__main__':main() diff --git a/research/p104-joint-contact/funding-peer/inputs/AUDITED-CANDIDATE-WORD.json.gz b/research/p104-joint-contact/funding-peer/inputs/AUDITED-CANDIDATE-WORD.json.gz new file mode 100644 index 0000000000..bb4064cdef Binary files /dev/null and b/research/p104-joint-contact/funding-peer/inputs/AUDITED-CANDIDATE-WORD.json.gz differ diff --git a/research/p104-joint-contact/funding-peer/inputs/PUBLIC-PROOF.md b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-PROOF.md new file mode 100644 index 0000000000..aab8a124f5 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-PROOF.md @@ -0,0 +1,142 @@ +# Coupled contacts and complete conditional price + +The endpoint is `kappa = 304153/100000000 = .00304153`, improving Ali +Romman's PR5545 endpoint `.00304117` by `9/25000000 = .00000036`. +Source head: `18968423711fd902aaee1099979497d55603e1dc`. +The selected record is unchanged. All five framework premises remain: +native all-column implementation, owned erasure, uniform compiler, +precision and tape costs, and analytic recovery. This proves an ideal +operator change and a complete conditional price; the enormous uniform +word and rounded integer multiplier are not materialized. + +## Literal change and all-width implication + +`construct.py` pins these six zero-based source events: + +| Event | Unchanged scalar operation | Old frame | New frame | +| --- | --- | --- | --- | +| 10461 | `297 += 303` | 335 | 17 | +| 10462 | `303 -= 297/2` | 335 | 17 | +| 13970 | `152 -= 297/2` | 335 | 17 | +| 15479 | `198 += 319` | 915 | 207 | +| 15639 | `205 += 198` | 915 | 207 | +| 15640 | `198 -= 205/2` | 915 | 207 | + +Frame 335 has dimension two. Frame 17 is `span(145)`, dimension one. +Frame 915 has dimension seven. Frame 207 has dimension eight and basis +`[2,5,8,17,33,65,129,257]`. All are existing source canonical charts. +No new coordinate transformation is granted for free. + +The emitter issues every nested MOVE needed to place both operands at +the declared common frame. SCALE occurs at its operand's current frame; +terminal public MOVEs finish at the original exits. Fifteen SCALE chart +annotations change; every scalar coefficient and its order is retained. +INIT/COPY/CLEAR lifetimes are unchanged. Every actual intervening source +read and write is included in the complete replay. The word has 25,310 events. + +The separate [peer proof](peer/PROOF.md) and +[role histories](peer/RECEIPT.json) bind the actual field versions. In the +first group, role 297 coalesces two rank-one rises into rank two; role 303 +splits rank two into two rank-one rises; role 152 replaces two rank-two +rises by ranks one and three. Their net delta is `H1 - 2H2 + H3`. +In the second group, role 198 replaces ranks four plus one by rank five; +role 319 exchanges the order of ranks one and two with zero profile delta; +role 205 splits rank two into two rank-one rises. The net delta is +`H1 - H2 - H4 + H5`. + +Let Phi_F be the exact canonical source chart. At field width f, a role +stores Phi_F tensor-power f applied to its logical value. A MOVE F to G +applies `Phi_G Phi_F^{-1}` tensor-power f, preserving that logical value. +Same-chart ADD/COPY acts on logical values with its scalar applied once, +outside tensor powers. SCALE commutes with transport by linearity. Thus +the unchanged scalar/owned word and fixed endpoint charts imply exactly +the same complete physical operator at every positive f. This is a +compositional induction: no sum is tensor-powered and no width-one +linear-independence claim is used. + +Three exact endpoint checks cover all 743 rows and 552,049 coefficients: +sparse rational forward rows, dense integer reverse columns with binary +denominators, and an independently written integer/dyadic peer interpreter +that imports neither constructor nor native checker. All 735 public inputs +remain arbitrary. All 527 productive helpers retain their targets. Eight +owned lifetimes retain peak occupancy one and the original erasure premise. + +The source native compiler freshly lowers every MOVE, helper boundary and +main adapter. Its separate Gaussian interpreter compares every signed Pauli +image and absolute global phase: 2,979 distinct maps, 1,054 helper normalizers +and 208 main adapters. Wrong phase is rejected. These exact base identities +tensor to every positive f. The unchanged complete caller is freshly checked +through its Laurent identity, 265-axis phase polynomial, 104 ports, both +orientations and actual orthogonal routes. This algebraic check is distinct +from materializing exponential-size all-column matrices. + +## Complete moment and transfer + +The new local paid profile is + +```text +{1:2430, 2:554, 3:390, 4:111, 5:108, 6:17, 7:13, 9:1}. +``` + +Its delta from PR5545 is + +```text +local: +2H1 -3H2 +H3 -H4 +H5 +complete: +36H1 -54H2 +18H3 -18H4 +18H5 +target: zero at every rank. +``` + +For `H_r=r^t`, `0 H6` edit +and lies outside PR5548's narrow repetition ceiling. + +Each invocation retains helper targets `{4:51,5:36,7:24,8:122,9:294}`. +The full bill includes 18 forward invocations, 15 genuine queries, 15 whole +idles and 32 main banks: 69,912 paid calls, 12,814 productive fields and rank +surplus 760. Maximum paid/target ranks remain 72/145. No helper is omitted. + +`pricing.py` retains PR5544/5545's funding argument. New mathematical +parameters are claimed/tested saving and comparison endpoint; its input +histogram comes from the freshly replayed word. Two independent full +invoice counts and both inherited rational moment engines must agree. +The strict raw crossing enclosure is + +```text +.00304153116714 < raw crossing < .00304153116715. +``` + +Tested saving is `.0030415305`. Cutoff 17, floor 18, tail offset 1/5, +power 1024, reserve `10^-10` and logarithm power 1000 fund completion, +splitting and rounding. Compiler gap is `1/14000000000`, integer height +`H=690116000000000`, test exponent 49,294; the preceding integer point +fails. Ordinary/admitted BIT stock checks and all 54 strict plus four +functional outer predicates pass. `RESULT.json` records exact rationals. +The endpoint gain is not claimed to equal the raw-crossing difference, +which has different safety margins. No global optimum is claimed. + +Scalar coefficients and counts are unchanged. The 26,000-event bound, +per-event scalar growth below `2^16`, total local Gaussian rank 5,894 and +owned peak one still bound reordered prefixes. Local native ranks stay +at most nine. Routing, normalization, COPY, caller and erasure allowances +are recomputed; no precision/tape cost is set to zero. The same five +framework premises remain necessary. + +## Controls, source retention and credit + +The verifier rejects an old-chart contact, wrong butterfly coefficient, +changed source event and uncharged recursive call. The peer also rejects +missing owned CLEAR. Inherited checks reject missing central translation, +wrong native phase, adverse completion cutoff and inadequate BIT saving. +All 33 dependency files are authenticated before imports. The closed +official export retains the exact PR5545 bytes and source attribution. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance, Apache-2.0. +These are author-side checks, not independent human/proof-kernel acceptance. +Credit Ali Romman for PR5544/5545's caller and price; Gareth Davidson for +PR2305; David Arias for PR2152; Cinna Davis for PR2219/controller; Jacob +Alan Sussman for productive recursion; zxv for compiler/outer machinery; +Cao Yifan for pricing; and all geometry, common-chart, dual-ADD, native, +COPY, precision and analytic predecessors in the retained proofs. The +new contribution is this coupled literal itinerary and conditional gain. diff --git a/research/p104-joint-contact/funding-peer/inputs/PUBLIC-README.md b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-README.md new file mode 100644 index 0000000000..4f2263a251 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-README.md @@ -0,0 +1,102 @@ +# Conditional kappa .00304153 from coupled P104 contacts + +This contribution increases complete conditional kappa from **.00304117 in +[PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545)** to +**.00304153**, a gain of **.00000036**. Six ADD contacts change frame while +every scalar coefficient and its order remain identical. The selected record +remains .003027288235 and is not edited. + +The first three contacts involve registers 297, 303 and 152; the other three +involve 198, 319 and 205. The exact source events and replacement frames are +listed in [construct.py](construct.py). Their joint local paid delta is + +```text +2 H1 - 3 H2 + H3 - H4 + H5. +``` + +Each of the 18 local calls uses this change. The complete bill still has +**69,912 paid calls and 12,814 productive fields**, with rank-mass surplus +760 and maximum child/target ranks 72/145. Its distribution changes enough +to reduce the concave moment. All 735 independent public inputs, 743 endpoint +rows, productive targets and eight owned lifetimes are retained; peak owned +occupancy remains one. + +These are **author-checked conditional results**. The claim is tested at +.0030415305, with raw crossing in +(.00304153116714, .00304153116715). The five inherited premises remain: +native all-column implementation, owned erasure, the uniform compiler, +precision and tape costs, and analytic recovery. The enormous uniform word +and complete rounded multiplier are not materialized. No independent human +or proof-kernel acceptance, merge or selected-frontier update is claimed. + +Read [PROOF.md](PROOF.md), [the full receipt](RESULT.json), +[the emitted word](WORD.json.gz), [the complete pricing code](pricing.py) +and [the source pins](SOURCES.json). No global optimum is claimed. + +## Replay and source closure + +Python 3.12 and the standard library suffice. From the repository root: + +```sh +python3 -B scripts/research_package.py --package research/p104-joint-contact --check-only +python3.12 -B scripts/research_package.py --package research/p104-joint-contact +``` + +[VERIFY.json](VERIFY.json) registers normal and optimized execution of the +same complete verifier, with a 600-second bound per command. The verifier +authenticates the retained predecessor, reconstructs the literal replacement, +checks the complete scalar and signed native endpoints, checks the physical +caller and full invoices, and evaluates both rational moment engines, +compiler/stock conditions and all outer predicates. The receipt and +[VALIDATION.md](VALIDATION.md) distinguish the checks actually executed from +the inherited premises. Metadata validation alone is not scientific replay. + +The source is Ali Romman's PR5545 at +`18968423711fd902aaee1099979497d55603e1dc`. Its **unchanged official source +export** is retained as +[inputs/pr5545-source-closure.tar.gz](inputs/pr5545-source-closure.tar.gz). +The custom verifier checks the compressed capsule, embedded export manifest +and all 33 payload files before importing source modules. This capsule is a +dependency: its proof and embedded attribution remain unchanged, and all +source-specific notices continue to apply. Those 33 files are not newly +authored contributions. No foreign-history Git pin is used. The generic +package metadata pins canonical main +`32890bc5de034ab8fc93ac88ead7279a6a416d04` and its revision-7 task card as +historical provenance. The package-local capsule participates in ordinary +package-change invalidation. + +## Open next questions + +Independent review should check the six source sites, their complete frame +paths and source-read intervals, then replay the arbitrary-input native +identity and both complete moment engines. This matters because the result +still depends on the inherited framework premises. No technical source +dependency is missing; independent scientific acceptance remains pending. +The structured handoff is in [TASK.json](TASK.json). + +A later improvement must change a paid path or a productive target contract +and fund the entire caller. Refining the digits of this fixed crossing does +not supply a further structural gain. + +## Credit + +Ali Romman's [PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545) +supplies the starting contact word; his +[PR5544](https://github.com/CrocSwap/integer-mult-bounds/pull/5544) supplies +the productive caller, scalar interpreters and complete pricing engine. +Gareth Davidson (@bitplane) supplied +[PR2305](https://github.com/CrocSwap/integer-mult-bounds/pull/2305), joining +David Arias's (@DavidAriasC) +[PR2152](https://github.com/CrocSwap/integer-mult-bounds/pull/2152) coalesced +word and Cinna Davis's (@1337isnot1337) +[PR2219](https://github.com/CrocSwap/integer-mult-bounds/pull/2219) private +reuse. The general common-chart two-operand transport identity is inherited; +the contribution here is this coupled source-pinned itinerary and its +complete conditional cost gain. + +Retain Jacob Alan Sussman's productive recursion, Cinna Davis's controller, +zxv's compiler and outer machinery, Cao Yifan's pricing lineage, and every +geometry, scalar, native, COPY, precision and analytic author named in the +retained source proofs and notices. Prepared for thu-nmrc with substantial +OpenAI Codex assistance, including parallel subagents. These are author-side +checks. New work is Apache-2.0. diff --git a/research/p104-joint-contact/funding-peer/inputs/PUBLIC-RESULT.json b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-RESULT.json new file mode 100644 index 0000000000..a83db6d025 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-RESULT.json @@ -0,0 +1,332 @@ +{ + "complete_cost": { + "compiler": { + "H": 690116000000000, + "N": "2^690116000000000", + "eta": { + "lower": "0.000000184942858502899385581767", + "upper": "0.000000184942858502899385581768" + }, + "gap": "1/14000000000", + "integer_test_exponent": 49294, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "21290713/7000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "9/25000000", + "kappa": "304153/100000000", + "kappa_decimal": ".00304153", + "margin_at_previous": { + "lower": "0.089671185966380263298820901941", + "upper": "0.089671185966380263298820901942" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_routes": 5334000, + "local_scalar": 217428, + "peak_owned_fields": 1, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "3485999999253/3500000000000", + "fixed_halo_explicit_metadata_branch": "269500000001/3500000000", + "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000", + "new_semantic_group_guard": "3/14000000000" + }, + "margins": { + "boundary_algebraic_matrix": "596139935957418577/196000000000000000000", + "fused_gaussian": "596139935872255731/196000000000000000000", + "global_coordinate_router": "2661339/875000000", + "group_bit_router": "37258746867015983/12250000000000000000", + "group_scans": "6999999999/7000000000", + "main_transform": "596139921957418577/196000000000000000000", + "microbox_face_corrections": "269500000001/3500000000", + "polynomial_products": "13999999999/14000000000", + "sparse_union_movement": "80221139935957418577/196000000000000000000" + }, + "parameters": { + "a": "2661339/875000000", + "b": "1703257/560000000", + "beta": "13999999997/14000000000", + "bit_saving": "17/5000", + "cap_xi": "178221139921957418577/196000000000000000000", + "complex_uniform_saving": "21290713/7000000000", + "d": "1/14000000000", + "epsilon": "13999999999/14000000000", + "kappa": "304153/100000000", + "lambda_": "3987833879/4000000000", + "lambda_prime": "13957418577/14000000000", + "layout": "1/14000000000", + "q": "42581423/14000000000", + "r0": "1/140000000000", + "stop": "1/14000000000", + "tested_saving": "6083061/2000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "313661/875000000", + "actual_logarithmic_gamma_guard": "1/14000000000", + "actual_logarithmic_group_guard": "17778860099042581423/98000000000000000000", + "alpha_logarithm_absorption": "1/140000000000", + "boundary_algebraic_matrix_above_kappa": "55957418577/196000000000000000000", + "cap_above_band": "80221139921957418577/196000000000000000000", + "cap_below_cell": "17778860064042581423/196000000000000000000", + "cap_below_phase_cell_power": "213778860078042581423/196000000000000000000", + "complex_above_effective": "1/14000000000", + "complex_below_one_over_32": "15796743/560000000", + "complex_endpoint": "1/7000000000", + "epsilon_below_one": "1/14000000000", + "epsilon_positive": "13999999999/14000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "55872255731/196000000000000000000", + "gaussian_above_main": "6957418577/98000000000000000000", + "global_coordinate_router_above_kappa": "1/3500000000", + "global_gamma_power_slack": "9/140000000000", + "group_below_dimension": "1/7000000000", + "group_bit_router_above_kappa": "4367015983/12250000000000000000", + "group_gauge_power_slack": "17778860098342581423/98000000000000000000", + "group_key_fits_record": "1/7000000000", + "group_positive": "13999999997/14000000000", + "group_scans_above_kappa": "6978709289/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "655279790400418148631/500000000000000000000000", + "lambda_above_internal": "1/28000000000", + "lambda_above_sigma": "3/28000000000", + "lambda_above_tau": "1/28000000000", + "lambda_prime_above_lambda": "1/28000000000", + "lambda_prime_above_leaf": "1118296743/7840000000000000000", + "leaf_saving_above_effective": "558296743/7840000000000000000", + "main_transform_above_kappa": "41957418577/196000000000000000000", + "membership_arithmetic_fits_record": "1/14000000000", + "microbox_face_corrections_above_kappa": "134744677323/1750000000", + "microbox_halo_volume": "1106000000003/14000000000", + "new_complex_uniform_saving_above_b": "1/14000000000", + "new_semantic_guard_with_C1_one": "1/14000000000", + "polynomial_products_above_kappa": "13957418579/14000000000", + "positive_layout_slack": "1/14000000000", + "q_below_effective": "1/14000000000", + "q_below_internal": "1/14000000000", + "q_below_leaf": "1118296743/7840000000000000000", + "q_positive": "42581423/14000000000", + "short_record_fallback": "558296743/560000000", + "source_axis_superpolynomial": "1/14000000000", + "sparse_union_movement_above_kappa": "79625000055957418577/196000000000000000000", + "stop_below_one": "13999999999/14000000000", + "stop_positive": "1/14000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/14000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/14000000000", + "union_tag_work_per_visit_fits_record": "3/14000000000" + } + }, + "paid": { + "1": 45300, + "16": 416, + "2": 9972, + "24": 416, + "3": 7020, + "32": 416, + "4": 1998, + "40": 416, + "48": 416, + "5": 1944, + "56": 416, + "6": 306, + "64": 416, + "7": 234, + "72": 208, + "9": 18 + }, + "paid_calls": 69912, + "previous_open_pr5545": "304117/100000000", + "productive_fields": 12814, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_headroom": [ + "58357/50000000000000", + "23343/20000000000000" + ], + "raw_root_interval": [ + "152076558357/50000000000000", + "60830623343/20000000000000" + ], + "relative_gain_percent": "3600/304117", + "strictification": { + "alpha": { + "lower": "0.999999999302190665441264809032", + "upper": "0.999999999302190665441264809033" + }, + "cutoff": 17, + "delta": { + "lower": "0.963355290100190429734309350200", + "upper": "0.963355290100190429734309350201" + }, + "floor": 18, + "gamma": { + "lower": "0.965231303139134897171411452319", + "upper": "0.965231303139134897171411452320" + }, + "normalized_paid_upper": "5242880004882813/5242880536870912", + "power": 1024, + "reserve": "1/10000000000", + "tail_offset": "1/5", + "tested": "6083061/2000000000" + }, + "targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "4": 918, + "41": 416, + "49": 416, + "5": 648, + "57": 416, + "65": 416, + "7": 432, + "73": 208, + "8": 2196, + "9": 5292 + }, + "whole_idle_jobs": 3120 + }, + "complete_paid_delta": { + "1": 36, + "2": -54, + "3": 18, + "4": -18, + "5": 18 + }, + "independent_peer_science_sha256": "357bf2617d364fb951c704b0bba7bb920629494686ab3866fed910fb0f2f57fc", + "limits": [ + "The five framework assumptions retained by PR5544/5545 remain.", + "The uniform compiler word and complete rounded multiplier are not materialized.", + "No independent human or proof-kernel acceptance, selected promotion, or core-contributor status is claimed." + ], + "local": { + "endpoint_coefficients": 552049, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "owned_lifetimes": 8, + "paid": { + "1": 2430, + "2": 554, + "3": 390, + "4": 111, + "5": 108, + "6": 17, + "7": 13, + "9": 1 + }, + "peak_owned_fields": 1, + "public_inputs": 735, + "real_scalar_allowance": 217428 + }, + "local_paid_delta": { + "1": 2, + "2": -3, + "3": 1, + "4": -1, + "5": 1 + }, + "native": { + "distinct_maps": 2979, + "helper_normalizers": 1054, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "f7dac0d38942f0b02ad21c166281aeed704bc133421843f2b0ededaaf654e4a9", + "wrong_phase_rejected": true + }, + "negative_controls": { + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "one_operand_or_contact_left_at_old_chart": "Scalar destination and coefficient", + "stale_source_or_changed_read": "Exact source ADD at 10461", + "uncharged_recursive_call": "Complete field and call counts", + "wrong_butterfly_coefficient": "All 743 public and owned rows" + }, + "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 + ] + }, + "retained_source_files": 33, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 552049, + "columns": 743 + }, + "source_commit": "18968423711fd902aaee1099979497d55603e1dc", + "status": "PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153" +} diff --git a/research/p104-joint-contact/funding-peer/inputs/PUBLIC-WORD.json.gz b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-WORD.json.gz new file mode 100644 index 0000000000..c04a815c26 Binary files /dev/null and b/research/p104-joint-contact/funding-peer/inputs/PUBLIC-WORD.json.gz differ diff --git a/research/p104-joint-contact/funding-peer/inputs/SOURCES.json b/research/p104-joint-contact/funding-peer/inputs/SOURCES.json new file mode 100644 index 0000000000..8d83feec6e --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/SOURCES.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ], + "retained_source": { + "path": "research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz", + "sha256": "59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837", + "export_manifest_sha256": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "commit": "18968423711fd902aaee1099979497d55603e1dc", + "files": 33, + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5545" + }, + "retained_source_scope": "Exact predecessor export used as a byte-authenticated source dependency. The custom verifier checks the capsule, embedded export manifest and all 33 payload files. This is not a foreign-history Git pin or a claim that the predecessor is newly authored here." +} diff --git a/research/p104-joint-contact/funding-peer/inputs/complete_cost.json b/research/p104-joint-contact/funding-peer/inputs/complete_cost.json new file mode 100644 index 0000000000..9841f54155 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/complete_cost.json @@ -0,0 +1,208 @@ +{ + "compiler": { + "H": 690116000000000, + "N": "2^690116000000000", + "eta": { + "lower": "0.000000184942858502899385581767", + "upper": "0.000000184942858502899385581768" + }, + "gap": "1/14000000000", + "integer_test_exponent": 49294, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "21290713/7000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "9/25000000", + "kappa": "304153/100000000", + "kappa_decimal": ".00304153", + "margin_at_previous": { + "lower": "0.089671185966380263298820901941", + "upper": "0.089671185966380263298820901942" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_routes": 5334000, + "local_scalar": 217428, + "peak_owned_fields": 1, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "3485999999253/3500000000000", + "fixed_halo_explicit_metadata_branch": "269500000001/3500000000", + "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000", + "new_semantic_group_guard": "3/14000000000" + }, + "margins": { + "boundary_algebraic_matrix": "596139935957418577/196000000000000000000", + "fused_gaussian": "596139935872255731/196000000000000000000", + "global_coordinate_router": "2661339/875000000", + "group_bit_router": "37258746867015983/12250000000000000000", + "group_scans": "6999999999/7000000000", + "main_transform": "596139921957418577/196000000000000000000", + "microbox_face_corrections": "269500000001/3500000000", + "polynomial_products": "13999999999/14000000000", + "sparse_union_movement": "80221139935957418577/196000000000000000000" + }, + "parameters": { + "a": "2661339/875000000", + "b": "1703257/560000000", + "beta": "13999999997/14000000000", + "bit_saving": "17/5000", + "cap_xi": "178221139921957418577/196000000000000000000", + "complex_uniform_saving": "21290713/7000000000", + "d": "1/14000000000", + "epsilon": "13999999999/14000000000", + "kappa": "304153/100000000", + "lambda_": "3987833879/4000000000", + "lambda_prime": "13957418577/14000000000", + "layout": "1/14000000000", + "q": "42581423/14000000000", + "r0": "1/140000000000", + "stop": "1/14000000000", + "tested_saving": "6083061/2000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "313661/875000000", + "actual_logarithmic_gamma_guard": "1/14000000000", + "actual_logarithmic_group_guard": "17778860099042581423/98000000000000000000", + "alpha_logarithm_absorption": "1/140000000000", + "boundary_algebraic_matrix_above_kappa": "55957418577/196000000000000000000", + "cap_above_band": "80221139921957418577/196000000000000000000", + "cap_below_cell": "17778860064042581423/196000000000000000000", + "cap_below_phase_cell_power": "213778860078042581423/196000000000000000000", + "complex_above_effective": "1/14000000000", + "complex_below_one_over_32": "15796743/560000000", + "complex_endpoint": "1/7000000000", + "epsilon_below_one": "1/14000000000", + "epsilon_positive": "13999999999/14000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "55872255731/196000000000000000000", + "gaussian_above_main": "6957418577/98000000000000000000", + "global_coordinate_router_above_kappa": "1/3500000000", + "global_gamma_power_slack": "9/140000000000", + "group_below_dimension": "1/7000000000", + "group_bit_router_above_kappa": "4367015983/12250000000000000000", + "group_gauge_power_slack": "17778860098342581423/98000000000000000000", + "group_key_fits_record": "1/7000000000", + "group_positive": "13999999997/14000000000", + "group_scans_above_kappa": "6978709289/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "655279790400418148631/500000000000000000000000", + "lambda_above_internal": "1/28000000000", + "lambda_above_sigma": "3/28000000000", + "lambda_above_tau": "1/28000000000", + "lambda_prime_above_lambda": "1/28000000000", + "lambda_prime_above_leaf": "1118296743/7840000000000000000", + "leaf_saving_above_effective": "558296743/7840000000000000000", + "main_transform_above_kappa": "41957418577/196000000000000000000", + "membership_arithmetic_fits_record": "1/14000000000", + "microbox_face_corrections_above_kappa": "134744677323/1750000000", + "microbox_halo_volume": "1106000000003/14000000000", + "new_complex_uniform_saving_above_b": "1/14000000000", + "new_semantic_guard_with_C1_one": "1/14000000000", + "polynomial_products_above_kappa": "13957418579/14000000000", + "positive_layout_slack": "1/14000000000", + "q_below_effective": "1/14000000000", + "q_below_internal": "1/14000000000", + "q_below_leaf": "1118296743/7840000000000000000", + "q_positive": "42581423/14000000000", + "short_record_fallback": "558296743/560000000", + "source_axis_superpolynomial": "1/14000000000", + "sparse_union_movement_above_kappa": "79625000055957418577/196000000000000000000", + "stop_below_one": "13999999999/14000000000", + "stop_positive": "1/14000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/14000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/14000000000", + "union_tag_work_per_visit_fits_record": "3/14000000000" + } + }, + "paid": { + "1": 45300, + "16": 416, + "2": 9972, + "24": 416, + "3": 7020, + "32": 416, + "4": 1998, + "40": 416, + "48": 416, + "5": 1944, + "56": 416, + "6": 306, + "64": 416, + "7": 234, + "72": 208, + "9": 18 + }, + "paid_calls": 69912, + "previous_open_pr5545": "304117/100000000", + "productive_fields": 12814, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_headroom": [ + "58357/50000000000000", + "23343/20000000000000" + ], + "raw_root_interval": [ + "152076558357/50000000000000", + "60830623343/20000000000000" + ], + "relative_gain_percent": "3600/304117", + "strictification": { + "alpha": { + "lower": "0.999999999302190665441264809032", + "upper": "0.999999999302190665441264809033" + }, + "cutoff": 17, + "delta": { + "lower": "0.963355290100190429734309350200", + "upper": "0.963355290100190429734309350201" + }, + "floor": 18, + "gamma": { + "lower": "0.965231303139134897171411452319", + "upper": "0.965231303139134897171411452320" + }, + "normalized_paid_upper": "5242880004882813/5242880536870912", + "power": 1024, + "reserve": "1/10000000000", + "tail_offset": "1/5", + "tested": "6083061/2000000000" + }, + "targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "4": 918, + "41": 416, + "49": 416, + "5": 648, + "57": 416, + "65": 416, + "7": 432, + "73": 208, + "8": 2196, + "9": 5292 + }, + "whole_idle_jobs": 3120 +} diff --git a/research/p104-joint-contact/funding-peer/inputs/controller.json b/research/p104-joint-contact/funding-peer/inputs/controller.json new file mode 100644 index 0000000000..cc539db709 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/controller.json @@ -0,0 +1,5480 @@ +{ + "ambient_rank": 145, + "boundaries": { + "left": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "1", + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "left_program": [ + [ + "SWAP", + 30, + 31 + ], + [ + "SWAP", + 29, + 30 + ], + [ + "SWAP", + 28, + 30 + ], + [ + "SWAP", + 27, + 29 + ], + [ + "SWAP", + 26, + 28 + ], + [ + "SWAP", + 25, + 30 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "SWAP", + 23, + 26 + ], + [ + "SWAP", + 22, + 30 + ], + [ + "SWAP", + 20, + 26 + ], + [ + "SWAP", + 19, + 22 + ], + [ + "SWAP", + 18, + 29 + ], + [ + "SWAP", + 17, + 23 + ], + [ + "SWAP", + 16, + 27 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "SWAP", + 15, + 31 + ], + [ + "ADD", + 12, + 14, + "1" + ], + [ + "ADD", + 10, + 14, + "-1" + ], + [ + "ADD", + 8, + 14, + "1" + ], + [ + "ADD", + 6, + 14, + "-1" + ], + [ + "ADD", + 4, + 14, + "1" + ], + [ + "ADD", + 2, + 14, + "-1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 31, + 13, + "1" + ], + [ + "SWAP", + 13, + 30 + ], + [ + "ADD", + 10, + 12, + "1" + ], + [ + "ADD", + 8, + 12, + "-1" + ], + [ + "ADD", + 6, + 12, + "1" + ], + [ + "ADD", + 4, + 12, + "-1" + ], + [ + "ADD", + 2, + 12, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "SWAP", + 12, + 14 + ], + [ + "ADD", + 31, + 11, + "-1" + ], + [ + "ADD", + 30, + 11, + "-1" + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "SWAP", + 11, + 29 + ], + [ + "ADD", + 8, + 10, + "1" + ], + [ + "ADD", + 6, + 10, + "-1" + ], + [ + "ADD", + 4, + 10, + "1" + ], + [ + "ADD", + 2, + 10, + "-1" + ], + [ + "ADD", + 0, + 10, + "1" + ], + [ + "SWAP", + 10, + 13 + ], + [ + "ADD", + 31, + 9, + "1" + ], + [ + "ADD", + 30, + 9, + "1" + ], + [ + "ADD", + 29, + 9, + "1" + ], + [ + "SWAP", + 9, + 28 + ], + [ + "ADD", + 6, + 8, + "1" + ], + [ + "ADD", + 4, + 8, + "-1" + ], + [ + "ADD", + 2, + 8, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "SWAP", + 8, + 12 + ], + [ + "ADD", + 31, + 7, + "-1" + ], + [ + "ADD", + 30, + 7, + "-1" + ], + [ + "ADD", + 29, + 7, + "-1" + ], + [ + "ADD", + 28, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SWAP", + 7, + 27 + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 0, + 6, + "1" + ], + [ + "SWAP", + 6, + 11 + ], + [ + "ADD", + 31, + 5, + "1" + ], + [ + "ADD", + 30, + 5, + "1" + ], + [ + "ADD", + 29, + 5, + "1" + ], + [ + "ADD", + 28, + 5, + "1" + ], + [ + "ADD", + 27, + 5, + "1" + ], + [ + "SWAP", + 5, + 26 + ], + [ + "ADD", + 2, + 4, + "1" + ], + [ + "ADD", + 0, + 4, + "-1" + ], + [ + "SWAP", + 4, + 10 + ], + [ + "ADD", + 31, + 3, + "-1" + ], + [ + "ADD", + 30, + 3, + "-1" + ], + [ + "ADD", + 29, + 3, + "-1" + ], + [ + "ADD", + 28, + 3, + "-1" + ], + [ + "ADD", + 27, + 3, + "-1" + ], + [ + "ADD", + 26, + 3, + "-1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 25 + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SWAP", + 2, + 9 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 30, + 1, + "1" + ], + [ + "ADD", + 29, + 1, + "1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 26, + 1, + "1" + ], + [ + "ADD", + 25, + 1, + "1" + ], + [ + "SWAP", + 1, + 24 + ], + [ + "SWAP", + 0, + 8 + ] + ], + "right": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "-1", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ] + ], + "right_program": [ + [ + "ADD", + 30, + 31, + "-1" + ], + [ + "ADD", + 29, + 31, + "-1" + ], + [ + "ADD", + 28, + 31, + "-1" + ], + [ + "ADD", + 27, + 31, + "-1" + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 30, + "-1" + ], + [ + "ADD", + 29, + 30, + "-1" + ], + [ + "ADD", + 28, + 30, + "-1" + ], + [ + "ADD", + 27, + 30, + "-1" + ], + [ + "ADD", + 31, + 29, + "-1" + ], + [ + "ADD", + 28, + 29, + "-1" + ], + [ + "ADD", + 27, + 29, + "-1" + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 31, + 28, + "-1" + ], + [ + "ADD", + 27, + 28, + "-1" + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 31, + 27, + "-1" + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "SWAP", + 27, + 29 + ], + [ + "ADD", + 31, + 26, + "1" + ], + [ + "SWAP", + 26, + 29 + ], + [ + "ADD", + 29, + 25, + "-1" + ], + [ + "ADD", + 24, + 25, + "-1" + ], + [ + "SWAP", + 25, + 28 + ], + [ + "ADD", + 28, + 24, + "1" + ], + [ + "SWAP", + 23, + 29 + ], + [ + "SWAP", + 22, + 25 + ], + [ + "SWAP", + 20, + 23 + ], + [ + "SWAP", + 19, + 25 + ], + [ + "SWAP", + 18, + 27 + ], + [ + "SWAP", + 17, + 29 + ], + [ + "SWAP", + 16, + 31 + ], + [ + "ADD", + 14, + 15, + "-1" + ], + [ + "SWAP", + 15, + 30 + ], + [ + "ADD", + 13, + 14, + "-1" + ], + [ + "SWAP", + 14, + 30 + ], + [ + "ADD", + 12, + 13, + "-1" + ], + [ + "SWAP", + 13, + 22 + ], + [ + "ADD", + 11, + 12, + "-1" + ], + [ + "SWAP", + 12, + 30 + ], + [ + "ADD", + 10, + 11, + "-1" + ], + [ + "SWAP", + 11, + 18 + ], + [ + "ADD", + 9, + 10, + "-1" + ], + [ + "SWAP", + 10, + 22 + ], + [ + "ADD", + 8, + 9, + "-1" + ], + [ + "SWAP", + 9, + 26 + ], + [ + "SWAP", + 8, + 30 + ], + [ + "SWAP", + 7, + 16 + ], + [ + "SWAP", + 6, + 18 + ], + [ + "SWAP", + 5, + 20 + ], + [ + "SWAP", + 4, + 22 + ], + [ + "SWAP", + 3, + 24 + ], + [ + "SWAP", + 2, + 26 + ], + [ + "SWAP", + 1, + 28 + ], + [ + "SWAP", + 0, + 30 + ] + ] + }, + "diagonal": [ + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + -1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ] + ], + "keep_mask": 35047648968703, + "kind": "complex", + "pairs": 16, + "physical_events": [ + [ + "LOCAL", + 0, + 0, + false + ], + [ + "Q_POWER", + 0, + -2 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "LOCAL", + 1, + 0, + false + ], + [ + "Q_POWER", + 1, + 2 + ], + [ + "SIGNED_SWAP", + 1, + 0 + ], + [ + "IDLE", + 1, + [ + 0, + 1 + ] + ], + [ + "ADD", + 0, + 2, + 1 + ], + [ + "ADD", + 3, + 1, + -1 + ], + [ + "QUERY_SHEAR", + 2, + 0, + false + ], + [ + "ADD", + 0, + 2, + -1 + ], + [ + "ADD", + 3, + 1, + 1 + ], + [ + "Q_POWER", + 2, + -2 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "LOCAL", + 3, + 1, + false + ], + [ + "Q_POWER", + 3, + 2 + ], + [ + "SIGNED_SWAP", + 3, + 2 + ], + [ + "IDLE", + 2, + [ + 0, + 1, + 3 + ] + ], + [ + "ADD", + 2, + 4, + 1 + ], + [ + "ADD", + 5, + 3, + -1 + ], + [ + "QUERY_SHEAR", + 4, + 1, + false + ], + [ + "ADD", + 2, + 4, + -1 + ], + [ + "ADD", + 5, + 3, + 1 + ], + [ + "Q_POWER", + 4, + -2 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "LOCAL", + 5, + 2, + false + ], + [ + "Q_POWER", + 5, + 2 + ], + [ + "SIGNED_SWAP", + 5, + 4 + ], + [ + "IDLE", + 3, + [ + 0, + 1, + 3, + 5 + ] + ], + [ + "ADD", + 4, + 6, + 1 + ], + [ + "ADD", + 7, + 5, + -1 + ], + [ + "QUERY_SHEAR", + 6, + 2, + false + ], + [ + "ADD", + 4, + 6, + -1 + ], + [ + "ADD", + 7, + 5, + 1 + ], + [ + "Q_POWER", + 6, + -2 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "LOCAL", + 7, + 3, + false + ], + [ + "Q_POWER", + 7, + 2 + ], + [ + "SIGNED_SWAP", + 7, + 6 + ], + [ + "IDLE", + 4, + [ + 0, + 1, + 3, + 5, + 7 + ] + ], + [ + "ADD", + 6, + 8, + 1 + ], + [ + "ADD", + 9, + 7, + -1 + ], + [ + "QUERY_SHEAR", + 8, + 3, + false + ], + [ + "ADD", + 6, + 8, + -1 + ], + [ + "ADD", + 9, + 7, + 1 + ], + [ + "Q_POWER", + 8, + -2 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "LOCAL", + 9, + 4, + false + ], + [ + "Q_POWER", + 9, + 2 + ], + [ + "SIGNED_SWAP", + 9, + 8 + ], + [ + "IDLE", + 5, + [ + 0, + 1, + 3, + 5, + 7, + 9 + ] + ], + [ + "ADD", + 8, + 10, + 1 + ], + [ + "ADD", + 11, + 9, + -1 + ], + [ + "QUERY_SHEAR", + 10, + 4, + false + ], + [ + "ADD", + 8, + 10, + -1 + ], + [ + "ADD", + 11, + 9, + 1 + ], + [ + "Q_POWER", + 10, + -2 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "LOCAL", + 11, + 5, + false + ], + [ + "Q_POWER", + 11, + 2 + ], + [ + "SIGNED_SWAP", + 11, + 10 + ], + [ + "IDLE", + 6, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11 + ] + ], + [ + "ADD", + 10, + 12, + 1 + ], + [ + "ADD", + 13, + 11, + -1 + ], + [ + "QUERY_SHEAR", + 12, + 5, + false + ], + [ + "ADD", + 10, + 12, + -1 + ], + [ + "ADD", + 13, + 11, + 1 + ], + [ + "Q_POWER", + 12, + -2 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "LOCAL", + 13, + 6, + false + ], + [ + "Q_POWER", + 13, + 2 + ], + [ + "SIGNED_SWAP", + 13, + 12 + ], + [ + "IDLE", + 7, + [ + 0, + 1, + 3, + 5, + 7, + 9, + 11, + 13 + ] + ], + [ + "ADD", + 12, + 14, + 1 + ], + [ + "ADD", + 15, + 13, + -1 + ], + [ + "QUERY_SHEAR", + 14, + 6, + false + ], + [ + "ADD", + 12, + 14, + -1 + ], + [ + "ADD", + 15, + 13, + 1 + ], + [ + "Q_POWER", + 14, + -2 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "LOCAL", + 15, + 7, + false + ], + [ + "Q_POWER", + 15, + 2 + ], + [ + "SIGNED_SWAP", + 15, + 14 + ], + [ + "ADD", + 14, + 16, + 1 + ], + [ + "ADD", + 17, + 15, + -1 + ], + [ + "QUERY_SHEAR", + 16, + 7, + false + ], + [ + "ADD", + 14, + 16, + -1 + ], + [ + "ADD", + 17, + 15, + 1 + ], + [ + "Q_POWER", + 16, + -2 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "LOCAL", + 17, + 8, + false + ], + [ + "Q_POWER", + 17, + 2 + ], + [ + "SIGNED_SWAP", + 17, + 16 + ], + [ + "ADD", + 16, + 18, + 1 + ], + [ + "ADD", + 19, + 17, + -1 + ], + [ + "QUERY_SHEAR", + 18, + 8, + false + ], + [ + "ADD", + 16, + 18, + -1 + ], + [ + "ADD", + 19, + 17, + 1 + ], + [ + "Q_POWER", + 18, + -2 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "LOCAL", + 19, + 9, + false + ], + [ + "Q_POWER", + 19, + 2 + ], + [ + "SIGNED_SWAP", + 19, + 18 + ], + [ + "ADD", + 18, + 20, + 1 + ], + [ + "ADD", + 21, + 19, + -1 + ], + [ + "QUERY_SHEAR", + 20, + 9, + false + ], + [ + "ADD", + 18, + 20, + -1 + ], + [ + "ADD", + 21, + 19, + 1 + ], + [ + "Q_POWER", + 20, + -2 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "LOCAL", + 21, + 10, + false + ], + [ + "Q_POWER", + 21, + 2 + ], + [ + "SIGNED_SWAP", + 21, + 20 + ], + [ + "ADD", + 20, + 22, + 1 + ], + [ + "ADD", + 23, + 21, + -1 + ], + [ + "QUERY_SHEAR", + 22, + 10, + false + ], + [ + "ADD", + 20, + 22, + -1 + ], + [ + "ADD", + 23, + 21, + 1 + ], + [ + "Q_POWER", + 22, + -2 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "LOCAL", + 23, + 11, + false + ], + [ + "Q_POWER", + 23, + 2 + ], + [ + "SIGNED_SWAP", + 23, + 22 + ], + [ + "ADD", + 22, + 24, + 1 + ], + [ + "ADD", + 25, + 23, + -1 + ], + [ + "QUERY_SHEAR", + 24, + 11, + false + ], + [ + "ADD", + 22, + 24, + -1 + ], + [ + "ADD", + 25, + 23, + 1 + ], + [ + "Q_POWER", + 24, + -2 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "LOCAL", + 25, + 12, + false + ], + [ + "Q_POWER", + 25, + 2 + ], + [ + "SIGNED_SWAP", + 25, + 24 + ], + [ + "ADD", + 24, + 26, + 1 + ], + [ + "ADD", + 27, + 25, + -1 + ], + [ + "QUERY_SHEAR", + 26, + 12, + false + ], + [ + "ADD", + 24, + 26, + -1 + ], + [ + "ADD", + 27, + 25, + 1 + ], + [ + "Q_POWER", + 26, + -2 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "LOCAL", + 27, + 13, + false + ], + [ + "Q_POWER", + 27, + 2 + ], + [ + "SIGNED_SWAP", + 27, + 26 + ], + [ + "ADD", + 26, + 28, + 1 + ], + [ + "ADD", + 29, + 27, + -1 + ], + [ + "QUERY_SHEAR", + 28, + 13, + false + ], + [ + "ADD", + 26, + 28, + -1 + ], + [ + "ADD", + 29, + 27, + 1 + ], + [ + "Q_POWER", + 28, + -2 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "LOCAL", + 29, + 14, + false + ], + [ + "Q_POWER", + 29, + 2 + ], + [ + "SIGNED_SWAP", + 29, + 28 + ], + [ + "ADD", + 28, + 30, + 1 + ], + [ + "ADD", + 31, + 29, + -1 + ], + [ + "QUERY_SHEAR", + 30, + 14, + false + ], + [ + "ADD", + 28, + 30, + -1 + ], + [ + "ADD", + 31, + 29, + 1 + ], + [ + "Q_POWER", + 30, + -2 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ], + [ + "LOCAL", + 31, + 15, + false + ], + [ + "Q_POWER", + 31, + 2 + ], + [ + "SIGNED_SWAP", + 31, + 30 + ], + [ + "LOCAL", + 32, + 15, + false + ], + [ + "IDLE", + 7, + [ + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 8, + [ + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 9, + [ + 21, + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 10, + [ + 23, + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 11, + [ + 25, + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 12, + [ + 27, + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 13, + [ + 29, + 31, + 32 + ] + ], + [ + "IDLE", + 14, + [ + 31, + 32 + ] + ], + [ + "ADD", + 30, + 28, + 1 + ], + [ + "ADD", + 29, + 31, + -1 + ], + [ + "ADD", + 28, + 26, + 1 + ], + [ + "ADD", + 27, + 29, + -1 + ], + [ + "ADD", + 26, + 24, + 1 + ], + [ + "ADD", + 25, + 27, + -1 + ], + [ + "ADD", + 24, + 22, + 1 + ], + [ + "ADD", + 23, + 25, + -1 + ], + [ + "ADD", + 22, + 20, + 1 + ], + [ + "ADD", + 21, + 23, + -1 + ], + [ + "ADD", + 20, + 18, + 1 + ], + [ + "ADD", + 19, + 21, + -1 + ], + [ + "ADD", + 18, + 16, + 1 + ], + [ + "ADD", + 17, + 19, + -1 + ], + [ + "ADD", + 16, + 14, + 1 + ], + [ + "ADD", + 15, + 17, + -1 + ], + [ + "ADD", + 14, + 12, + 1 + ], + [ + "ADD", + 13, + 15, + -1 + ], + [ + "ADD", + 12, + 10, + 1 + ], + [ + "ADD", + 11, + 13, + -1 + ], + [ + "ADD", + 10, + 8, + 1 + ], + [ + "ADD", + 9, + 11, + -1 + ], + [ + "ADD", + 8, + 6, + 1 + ], + [ + "ADD", + 7, + 9, + -1 + ], + [ + "ADD", + 6, + 4, + 1 + ], + [ + "ADD", + 5, + 7, + -1 + ], + [ + "ADD", + 4, + 2, + 1 + ], + [ + "ADD", + 3, + 5, + -1 + ], + [ + "ADD", + 2, + 0, + 1 + ], + [ + "ADD", + 1, + 3, + -1 + ], + [ + "SIGNED_SWAP", + 0, + 1 + ], + [ + "SIGNED_SWAP", + 2, + 3 + ], + [ + "SIGNED_SWAP", + 4, + 5 + ], + [ + "SIGNED_SWAP", + 6, + 7 + ], + [ + "SIGNED_SWAP", + 8, + 9 + ], + [ + "SIGNED_SWAP", + 10, + 11 + ], + [ + "SIGNED_SWAP", + 12, + 13 + ], + [ + "SIGNED_SWAP", + 14, + 15 + ], + [ + "SIGNED_SWAP", + 16, + 17 + ], + [ + "SIGNED_SWAP", + 18, + 19 + ], + [ + "SIGNED_SWAP", + 20, + 21 + ], + [ + "SIGNED_SWAP", + 22, + 23 + ], + [ + "SIGNED_SWAP", + 24, + 25 + ], + [ + "SIGNED_SWAP", + 26, + 27 + ], + [ + "SIGNED_SWAP", + 28, + 29 + ], + [ + "SIGNED_SWAP", + 30, + 31 + ] + ], + "prefix_pairs": 7, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] +} diff --git a/research/p104-joint-contact/funding-peer/inputs/local-peer-RECEIPT.json b/research/p104-joint-contact/funding-peer/inputs/local-peer-RECEIPT.json new file mode 100644 index 0000000000..529e1545cd --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/local-peer-RECEIPT.json @@ -0,0 +1,2154 @@ +{ + "after": { + "endpoint_digest": "bdee5738e1cd4996799b7e214d7c5e51a72715500366d2c3adb88d1f693e347e", + "endpoint_rows": 743, + "endpoint_scalar_entries": 552049, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "opcodes": { + "ADD": 20947, + "CLEAR": 8, + "COPY": 8, + "INIT": 8, + "MOVE": 3624, + "SCALE": 715 + }, + "owned_lifetimes": 8, + "owned_peak": 1, + "paid": { + "1": 2430, + "2": 554, + "3": 390, + "4": 111, + "5": 108, + "6": 17, + "7": 13, + "9": 1 + } + }, + "allwidth_scope": "Each field stores Phi_frame^{tensor f} times its logical row. Exact chart-changing native MOVE interfaces and same-chart ADD/SCALE/COPY imply every positive field width with owner coefficients applied once. Native absolute-phase lowering is verified separately by the parent; this checker does not grant it or complete caller pricing.", + "before": { + "endpoint_digest": "bdee5738e1cd4996799b7e214d7c5e51a72715500366d2c3adb88d1f693e347e", + "endpoint_rows": 743, + "endpoint_scalar_entries": 552049, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "opcodes": { + "ADD": 20947, + "CLEAR": 8, + "COPY": 8, + "INIT": 8, + "MOVE": 3624, + "SCALE": 715 + }, + "owned_lifetimes": 8, + "owned_peak": 1, + "paid": { + "1": 2428, + "2": 557, + "3": 389, + "4": 112, + "5": 107, + "6": 17, + "7": 13, + "9": 1 + } + }, + "changes": [ + { + "after": [ + "ADD", + 297, + 303, + "1", + 17 + ], + "before": [ + "ADD", + 297, + 303, + "1", + 335 + ], + "candidate_event": 10460, + "scalar_ordinal": 10140, + "source_event": 10461 + }, + { + "after": [ + "ADD", + 303, + 297, + "-1/2", + 17 + ], + "before": [ + "ADD", + 303, + 297, + "-1/2", + 335 + ], + "candidate_event": 10461, + "scalar_ordinal": 10141, + "source_event": 10462 + }, + { + "after": [ + "ADD", + 152, + 297, + "-1/2", + 17 + ], + "before": [ + "ADD", + 152, + 297, + "-1/2", + 335 + ], + "candidate_event": 13970, + "scalar_ordinal": 12479, + "source_event": 13970 + }, + { + "after": [ + "ADD", + 198, + 319, + "1", + 207 + ], + "before": [ + "ADD", + 198, + 319, + "1", + 915 + ], + "candidate_event": 15479, + "scalar_ordinal": 13062, + "source_event": 15479 + }, + { + "after": [ + "ADD", + 205, + 198, + "1", + 207 + ], + "before": [ + "ADD", + 205, + 198, + "1", + 915 + ], + "candidate_event": 15640, + "scalar_ordinal": 13172, + "source_event": 15639 + }, + { + "after": [ + "ADD", + 198, + 205, + "-1/2", + 207 + ], + "before": [ + "ADD", + 198, + 205, + "-1/2", + 915 + ], + "candidate_event": 15641, + "scalar_ordinal": 13173, + "source_event": 15640 + }, + { + "after": [ + "SCALE", + 198, + "-2", + 207 + ], + "before": [ + "SCALE", + 198, + "-2", + 915 + ], + "candidate_event": 15642, + "scalar_ordinal": 13174, + "source_event": 15641 + }, + { + "after": [ + "SCALE", + 612, + "2", + 559 + ], + "before": [ + "SCALE", + 612, + "2", + 127 + ], + "candidate_event": 17501, + "scalar_ordinal": 14133, + "source_event": 17502 + }, + { + "after": [ + "SCALE", + 692, + "2", + 166 + ], + "before": [ + "SCALE", + 692, + "2", + 127 + ], + "candidate_event": 17571, + "scalar_ordinal": 14183, + "source_event": 17572 + }, + { + "after": [ + "SCALE", + 111, + "2", + 549 + ], + "before": [ + "SCALE", + 111, + "2", + 127 + ], + "candidate_event": 18792, + "scalar_ordinal": 15296, + "source_event": 18793 + }, + { + "after": [ + "SCALE", + 384, + "-1", + 518 + ], + "before": [ + "SCALE", + 384, + "-1", + 127 + ], + "candidate_event": 19121, + "scalar_ordinal": 15601, + "source_event": 19122 + }, + { + "after": [ + "SCALE", + 32, + "2", + 916 + ], + "before": [ + "SCALE", + 32, + "2", + 127 + ], + "candidate_event": 19253, + "scalar_ordinal": 15727, + "source_event": 19254 + }, + { + "after": [ + "SCALE", + 352, + "-1", + 517 + ], + "before": [ + "SCALE", + 352, + "-1", + 127 + ], + "candidate_event": 19268, + "scalar_ordinal": 15739, + "source_event": 19269 + }, + { + "after": [ + "SCALE", + 320, + "-1", + 517 + ], + "before": [ + "SCALE", + 320, + "-1", + 127 + ], + "candidate_event": 19597, + "scalar_ordinal": 16057, + "source_event": 19598 + }, + { + "after": [ + "SCALE", + 25, + "2", + 675 + ], + "before": [ + "SCALE", + 25, + "2", + 127 + ], + "candidate_event": 19797, + "scalar_ordinal": 16246, + "source_event": 19798 + }, + { + "after": [ + "SCALE", + 368, + "-1", + 517 + ], + "before": [ + "SCALE", + 368, + "-1", + 127 + ], + "candidate_event": 20180, + "scalar_ordinal": 16613, + "source_event": 20181 + }, + { + "after": [ + "SCALE", + 91, + "2", + 565 + ], + "before": [ + "SCALE", + 91, + "2", + 127 + ], + "candidate_event": 20477, + "scalar_ordinal": 16904, + "source_event": 20478 + }, + { + "after": [ + "SCALE", + 4, + "2", + 244 + ], + "before": [ + "SCALE", + 4, + "2", + 127 + ], + "candidate_event": 20689, + "scalar_ordinal": 17102, + "source_event": 20690 + }, + { + "after": [ + "SCALE", + 33, + "2", + 237 + ], + "before": [ + "SCALE", + 33, + "2", + 127 + ], + "candidate_event": 20774, + "scalar_ordinal": 17181, + "source_event": 20775 + }, + { + "after": [ + "SCALE", + 99, + "2", + 674 + ], + "before": [ + "SCALE", + 99, + "2", + 127 + ], + "candidate_event": 21410, + "scalar_ordinal": 17813, + "source_event": 21411 + }, + { + "after": [ + "SCALE", + 336, + "-1", + 518 + ], + "before": [ + "SCALE", + 336, + "-1", + 127 + ], + "candidate_event": 21921, + "scalar_ordinal": 18312, + "source_event": 21922 + } + ], + "mutation_controls": [ + { + "name": "wrong_scalar", + "reason": "exact endpoint row 18", + "rejected": true + }, + { + "name": "wrong_chart", + "reason": "destination chart", + "rejected": true + }, + { + "name": "omit_owned_clear", + "reason": "all exit charts and ownership", + "rejected": true + } + ], + "paid_delta": { + "1": 2, + "2": -3, + "3": 1, + "4": -1, + "5": 1 + }, + "schema": "p104-alpha-peer/1", + "source_pins": { + "CANDIDATE-WORD.json.gz": "535106a3caee2bc849b5d14438282ee211bafd31fc3d28e10137647673bbd15c", + "SOURCE-WORD.json.gz": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d" + }, + "status": "PASS_SCALAR_AND_TYPED_BOUNDARIES_NOT_NATIVE_PHASE_OR_COMPLETE_PRICE", + "transport_histories": { + "after": { + "4": [ + { + "before_scalar": 11044, + "event": 11715, + "private": false, + "rank": 1, + "source": 4, + "target": 439 + }, + { + "before_scalar": 11860, + "event": 12923, + "private": false, + "rank": 1, + "source": 439, + "target": 535 + }, + { + "before_scalar": 13754, + "event": 16833, + "private": false, + "rank": 1, + "source": 535, + "target": 244 + }, + { + "before_scalar": 17103, + "event": 20690, + "private": false, + "rank": 5, + "source": 244, + "target": 127 + } + ], + "25": [ + { + "before_scalar": 9818, + "event": 10003, + "private": false, + "rank": 1, + "source": 23, + "target": 292 + }, + { + "before_scalar": 12134, + "event": 13368, + "private": false, + "rank": 1, + "source": 292, + "target": 566 + }, + { + "before_scalar": 12573, + "event": 14216, + "private": false, + "rank": 2, + "source": 566, + "target": 669 + }, + { + "before_scalar": 12581, + "event": 14240, + "private": false, + "rank": 2, + "source": 669, + "target": 675 + }, + { + "before_scalar": 16247, + "event": 19799, + "private": false, + "rank": 2, + "source": 675, + "target": 127 + } + ], + "32": [ + { + "before_scalar": 10280, + "event": 10649, + "private": false, + "rank": 1, + "source": 30, + "target": 348 + }, + { + "before_scalar": 12145, + "event": 13397, + "private": false, + "rank": 1, + "source": 348, + "target": 572 + }, + { + "before_scalar": 13060, + "event": 15472, + "private": false, + "rank": 4, + "source": 572, + "target": 916 + }, + { + "before_scalar": 15728, + "event": 19255, + "private": false, + "rank": 2, + "source": 916, + "target": 127 + } + ], + "33": [ + { + "before_scalar": 10428, + "event": 10853, + "private": false, + "rank": 1, + "source": 31, + "target": 365 + }, + { + "before_scalar": 12148, + "event": 13405, + "private": false, + "rank": 1, + "source": 365, + "target": 573 + }, + { + "before_scalar": 13730, + "event": 16791, + "private": false, + "rank": 1, + "source": 573, + "target": 237 + }, + { + "before_scalar": 17182, + "event": 20775, + "private": false, + "rank": 5, + "source": 237, + "target": 127 + } + ], + "91": [ + { + "before_scalar": 9658, + "event": 9775, + "private": false, + "rank": 1, + "source": 85, + "target": 268 + }, + { + "before_scalar": 12124, + "event": 13344, + "private": false, + "rank": 1, + "source": 268, + "target": 561 + }, + { + "before_scalar": 12128, + "event": 13356, + "private": false, + "rank": 4, + "source": 561, + "target": 565 + }, + { + "before_scalar": 16905, + "event": 20478, + "private": false, + "rank": 2, + "source": 565, + "target": 127 + } + ], + "99": [ + { + "before_scalar": 11358, + "event": 12159, + "private": false, + "rank": 1, + "source": 92, + "target": 481 + }, + { + "before_scalar": 12135, + "event": 13371, + "private": false, + "rank": 1, + "source": 481, + "target": 567 + }, + { + "before_scalar": 12136, + "event": 13375, + "private": false, + "rank": 2, + "source": 567, + "target": 568 + }, + { + "before_scalar": 12580, + "event": 14237, + "private": false, + "rank": 2, + "source": 568, + "target": 674 + }, + { + "before_scalar": 17814, + "event": 21411, + "private": false, + "rank": 2, + "source": 674, + "target": 127 + } + ], + "111": [ + { + "before_scalar": 11506, + "event": 12363, + "private": false, + "rank": 1, + "source": 104, + "target": 499 + }, + { + "before_scalar": 11974, + "event": 13095, + "private": false, + "rank": 1, + "source": 499, + "target": 545 + }, + { + "before_scalar": 11978, + "event": 13107, + "private": false, + "rank": 4, + "source": 545, + "target": 549 + }, + { + "before_scalar": 15297, + "event": 18794, + "private": false, + "rank": 2, + "source": 549, + "target": 127 + } + ], + "152": [ + { + "before_scalar": 12479, + "event": 13969, + "private": false, + "rank": 1, + "source": 3, + "target": 17 + }, + { + "before_scalar": 12804, + "event": 14807, + "private": false, + "rank": 3, + "source": 17, + "target": 782 + }, + { + "before_scalar": 13033, + "event": 15392, + "private": false, + "rank": 3, + "source": 782, + "target": 905 + }, + { + "before_scalar": 13377, + "event": 16005, + "private": false, + "rank": 1, + "source": 905, + "target": 163 + } + ], + "198": [ + { + "before_scalar": 12269, + "event": 13640, + "private": false, + "rank": 1, + "source": 3, + "target": 597 + }, + { + "before_scalar": 12331, + "event": 13756, + "private": false, + "rank": 1, + "source": 597, + "target": 613 + }, + { + "before_scalar": 12471, + "event": 13950, + "private": false, + "rank": 1, + "source": 613, + "target": 615 + }, + { + "before_scalar": 13062, + "event": 15477, + "private": false, + "rank": 5, + "source": 615, + "target": 207 + } + ], + "205": [ + { + "before_scalar": 12304, + "event": 13718, + "private": false, + "rank": 1, + "source": 3, + "target": 106 + }, + { + "before_scalar": 12469, + "event": 13946, + "private": false, + "rank": 1, + "source": 106, + "target": 392 + }, + { + "before_scalar": 13055, + "event": 15456, + "private": false, + "rank": 5, + "source": 392, + "target": 915 + }, + { + "before_scalar": 13172, + "event": 15639, + "private": false, + "rank": 1, + "source": 915, + "target": 207 + }, + { + "before_scalar": 13478, + "event": 16231, + "private": false, + "rank": 1, + "source": 207, + "target": 127 + } + ], + "297": [ + { + "before_scalar": 10097, + "event": 10393, + "private": false, + "rank": 1, + "source": 3, + "target": 17 + }, + { + "before_scalar": 12670, + "event": 14477, + "private": false, + "rank": 2, + "source": 17, + "target": 720 + }, + { + "before_scalar": 13716, + "event": 16765, + "private": false, + "rank": 1, + "source": 720, + "target": 234 + }, + { + "before_scalar": 14296, + "event": 17719, + "private": false, + "rank": 5, + "source": 234, + "target": 127 + } + ], + "303": [ + { + "before_scalar": 10140, + "event": 10459, + "private": false, + "rank": 1, + "source": 3, + "target": 17 + }, + { + "before_scalar": 12478, + "event": 13967, + "private": false, + "rank": 1, + "source": 17, + "target": 335 + }, + { + "before_scalar": 12672, + "event": 14482, + "private": false, + "rank": 1, + "source": 335, + "target": 722 + }, + { + "before_scalar": 12800, + "event": 14795, + "private": false, + "rank": 3, + "source": 722, + "target": 778 + }, + { + "before_scalar": 13086, + "event": 15550, + "private": false, + "rank": 1, + "source": 778, + "target": 927 + }, + { + "before_scalar": 14100, + "event": 17449, + "private": false, + "rank": 2, + "source": 927, + "target": 127 + } + ], + "319": [ + { + "before_scalar": 10257, + "event": 10618, + "private": false, + "rank": 1, + "source": 3, + "target": 32 + }, + { + "before_scalar": 10294, + "event": 10677, + "private": false, + "rank": 1, + "source": 32, + "target": 355 + }, + { + "before_scalar": 12485, + "event": 13982, + "private": false, + "rank": 1, + "source": 355, + "target": 617 + }, + { + "before_scalar": 12686, + "event": 14516, + "private": false, + "rank": 1, + "source": 617, + "target": 728 + }, + { + "before_scalar": 12795, + "event": 14782, + "private": false, + "rank": 2, + "source": 728, + "target": 775 + }, + { + "before_scalar": 13062, + "event": 15478, + "private": false, + "rank": 2, + "source": 775, + "target": 207 + }, + { + "before_scalar": 14097, + "event": 17442, + "private": false, + "rank": 1, + "source": 207, + "target": 127 + } + ], + "320": [ + { + "before_scalar": 10396, + "event": 10806, + "private": false, + "rank": 1, + "source": 3, + "target": 45 + }, + { + "before_scalar": 10430, + "event": 10856, + "private": false, + "rank": 1, + "source": 45, + "target": 366 + }, + { + "before_scalar": 10453, + "event": 10902, + "private": false, + "rank": 1, + "source": 366, + "target": 376 + }, + { + "before_scalar": 10465, + "event": 10929, + "private": false, + "rank": 1, + "source": 376, + "target": 237 + }, + { + "before_scalar": 11665, + "event": 12608, + "private": false, + "rank": 4, + "source": 237, + "target": 517 + }, + { + "before_scalar": 16058, + "event": 19598, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "336": [ + { + "before_scalar": 10550, + "event": 11020, + "private": false, + "rank": 1, + "source": 3, + "target": 6 + }, + { + "before_scalar": 10584, + "event": 11070, + "private": false, + "rank": 1, + "source": 6, + "target": 384 + }, + { + "before_scalar": 10607, + "event": 11116, + "private": false, + "rank": 1, + "source": 384, + "target": 394 + }, + { + "before_scalar": 10619, + "event": 11143, + "private": false, + "rank": 1, + "source": 394, + "target": 240 + }, + { + "before_scalar": 11672, + "event": 12623, + "private": false, + "rank": 4, + "source": 240, + "target": 518 + }, + { + "before_scalar": 18313, + "event": 21922, + "private": false, + "rank": 1, + "source": 518, + "target": 127 + } + ], + "352": [ + { + "before_scalar": 10704, + "event": 11234, + "private": false, + "rank": 1, + "source": 3, + "target": 77 + }, + { + "before_scalar": 10738, + "event": 11286, + "private": false, + "rank": 1, + "source": 77, + "target": 402 + }, + { + "before_scalar": 10761, + "event": 11334, + "private": false, + "rank": 1, + "source": 402, + "target": 414 + }, + { + "before_scalar": 10773, + "event": 11361, + "private": false, + "rank": 1, + "source": 414, + "target": 242 + }, + { + "before_scalar": 11666, + "event": 12610, + "private": false, + "rank": 4, + "source": 242, + "target": 517 + }, + { + "before_scalar": 15740, + "event": 19269, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "368": [ + { + "before_scalar": 10858, + "event": 11452, + "private": false, + "rank": 1, + "source": 3, + "target": 74 + }, + { + "before_scalar": 10892, + "event": 11502, + "private": false, + "rank": 1, + "source": 74, + "target": 422 + }, + { + "before_scalar": 10915, + "event": 11548, + "private": false, + "rank": 1, + "source": 422, + "target": 432 + }, + { + "before_scalar": 10927, + "event": 11575, + "private": false, + "rank": 1, + "source": 432, + "target": 243 + }, + { + "before_scalar": 11667, + "event": 12612, + "private": false, + "rank": 4, + "source": 243, + "target": 517 + }, + { + "before_scalar": 16614, + "event": 20181, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "384": [ + { + "before_scalar": 11012, + "event": 11666, + "private": false, + "rank": 1, + "source": 3, + "target": 63 + }, + { + "before_scalar": 11046, + "event": 11718, + "private": false, + "rank": 1, + "source": 63, + "target": 440 + }, + { + "before_scalar": 11069, + "event": 11766, + "private": false, + "rank": 1, + "source": 440, + "target": 452 + }, + { + "before_scalar": 11081, + "event": 11793, + "private": false, + "rank": 1, + "source": 452, + "target": 244 + }, + { + "before_scalar": 11673, + "event": 12625, + "private": false, + "rank": 4, + "source": 244, + "target": 518 + }, + { + "before_scalar": 15602, + "event": 19122, + "private": false, + "rank": 1, + "source": 518, + "target": 127 + } + ], + "612": [ + { + "before_scalar": 11962, + "event": 13076, + "private": false, + "rank": 4, + "source": 112, + "target": 115 + }, + { + "before_scalar": 12003, + "event": 13166, + "private": false, + "rank": 1, + "source": 115, + "target": 556 + }, + { + "before_scalar": 12010, + "event": 13180, + "private": false, + "rank": 1, + "source": 556, + "target": 560 + }, + { + "before_scalar": 12012, + "event": 13183, + "private": false, + "rank": 1, + "source": 560, + "target": 559 + }, + { + "before_scalar": 14134, + "event": 17503, + "private": false, + "rank": 1, + "source": 559, + "target": 127 + } + ], + "692": [ + { + "before_scalar": 12368, + "event": 13809, + "private": false, + "rank": 3, + "source": 112, + "target": 125 + }, + { + "before_scalar": 13016, + "event": 15350, + "private": false, + "rank": 2, + "source": 125, + "target": 893 + }, + { + "before_scalar": 13643, + "event": 16597, + "private": false, + "rank": 1, + "source": 893, + "target": 1020 + }, + { + "before_scalar": 13646, + "event": 16602, + "private": false, + "rank": 1, + "source": 1020, + "target": 166 + }, + { + "before_scalar": 14184, + "event": 17573, + "private": false, + "rank": 1, + "source": 166, + "target": 127 + } + ] + }, + "before": { + "4": [ + { + "before_scalar": 11044, + "event": 11716, + "private": false, + "rank": 1, + "source": 4, + "target": 439 + }, + { + "before_scalar": 11860, + "event": 12924, + "private": false, + "rank": 1, + "source": 439, + "target": 535 + }, + { + "before_scalar": 13754, + "event": 16833, + "private": false, + "rank": 1, + "source": 535, + "target": 244 + }, + { + "before_scalar": 17102, + "event": 20689, + "private": false, + "rank": 5, + "source": 244, + "target": 127 + } + ], + "25": [ + { + "before_scalar": 9818, + "event": 10003, + "private": false, + "rank": 1, + "source": 23, + "target": 292 + }, + { + "before_scalar": 12134, + "event": 13369, + "private": false, + "rank": 1, + "source": 292, + "target": 566 + }, + { + "before_scalar": 12573, + "event": 14216, + "private": false, + "rank": 2, + "source": 566, + "target": 669 + }, + { + "before_scalar": 12581, + "event": 14240, + "private": false, + "rank": 2, + "source": 669, + "target": 675 + }, + { + "before_scalar": 16246, + "event": 19797, + "private": false, + "rank": 2, + "source": 675, + "target": 127 + } + ], + "32": [ + { + "before_scalar": 10280, + "event": 10650, + "private": false, + "rank": 1, + "source": 30, + "target": 348 + }, + { + "before_scalar": 12145, + "event": 13398, + "private": false, + "rank": 1, + "source": 348, + "target": 572 + }, + { + "before_scalar": 13060, + "event": 15472, + "private": false, + "rank": 4, + "source": 572, + "target": 916 + }, + { + "before_scalar": 15727, + "event": 19253, + "private": false, + "rank": 2, + "source": 916, + "target": 127 + } + ], + "33": [ + { + "before_scalar": 10428, + "event": 10854, + "private": false, + "rank": 1, + "source": 31, + "target": 365 + }, + { + "before_scalar": 12148, + "event": 13406, + "private": false, + "rank": 1, + "source": 365, + "target": 573 + }, + { + "before_scalar": 13730, + "event": 16791, + "private": false, + "rank": 1, + "source": 573, + "target": 237 + }, + { + "before_scalar": 17181, + "event": 20774, + "private": false, + "rank": 5, + "source": 237, + "target": 127 + } + ], + "91": [ + { + "before_scalar": 9658, + "event": 9775, + "private": false, + "rank": 1, + "source": 85, + "target": 268 + }, + { + "before_scalar": 12124, + "event": 13345, + "private": false, + "rank": 1, + "source": 268, + "target": 561 + }, + { + "before_scalar": 12128, + "event": 13357, + "private": false, + "rank": 4, + "source": 561, + "target": 565 + }, + { + "before_scalar": 16904, + "event": 20477, + "private": false, + "rank": 2, + "source": 565, + "target": 127 + } + ], + "99": [ + { + "before_scalar": 11358, + "event": 12160, + "private": false, + "rank": 1, + "source": 92, + "target": 481 + }, + { + "before_scalar": 12135, + "event": 13372, + "private": false, + "rank": 1, + "source": 481, + "target": 567 + }, + { + "before_scalar": 12136, + "event": 13376, + "private": false, + "rank": 2, + "source": 567, + "target": 568 + }, + { + "before_scalar": 12580, + "event": 14237, + "private": false, + "rank": 2, + "source": 568, + "target": 674 + }, + { + "before_scalar": 17813, + "event": 21410, + "private": false, + "rank": 2, + "source": 674, + "target": 127 + } + ], + "111": [ + { + "before_scalar": 11506, + "event": 12364, + "private": false, + "rank": 1, + "source": 104, + "target": 499 + }, + { + "before_scalar": 11974, + "event": 13096, + "private": false, + "rank": 1, + "source": 499, + "target": 545 + }, + { + "before_scalar": 11978, + "event": 13108, + "private": false, + "rank": 4, + "source": 545, + "target": 549 + }, + { + "before_scalar": 15296, + "event": 18792, + "private": false, + "rank": 2, + "source": 549, + "target": 127 + } + ], + "152": [ + { + "before_scalar": 12479, + "event": 13969, + "private": false, + "rank": 2, + "source": 3, + "target": 335 + }, + { + "before_scalar": 12804, + "event": 14807, + "private": false, + "rank": 2, + "source": 335, + "target": 782 + }, + { + "before_scalar": 13033, + "event": 15392, + "private": false, + "rank": 3, + "source": 782, + "target": 905 + }, + { + "before_scalar": 13377, + "event": 16004, + "private": false, + "rank": 1, + "source": 905, + "target": 163 + } + ], + "198": [ + { + "before_scalar": 12269, + "event": 13641, + "private": false, + "rank": 1, + "source": 3, + "target": 597 + }, + { + "before_scalar": 12331, + "event": 13757, + "private": false, + "rank": 1, + "source": 597, + "target": 613 + }, + { + "before_scalar": 12471, + "event": 13951, + "private": false, + "rank": 1, + "source": 613, + "target": 615 + }, + { + "before_scalar": 13062, + "event": 15477, + "private": false, + "rank": 4, + "source": 615, + "target": 915 + }, + { + "before_scalar": 13474, + "event": 16222, + "private": false, + "rank": 1, + "source": 915, + "target": 207 + } + ], + "205": [ + { + "before_scalar": 12304, + "event": 13719, + "private": false, + "rank": 1, + "source": 3, + "target": 106 + }, + { + "before_scalar": 12469, + "event": 13947, + "private": false, + "rank": 1, + "source": 106, + "target": 392 + }, + { + "before_scalar": 13055, + "event": 15456, + "private": false, + "rank": 5, + "source": 392, + "target": 915 + }, + { + "before_scalar": 13478, + "event": 16231, + "private": false, + "rank": 2, + "source": 915, + "target": 127 + } + ], + "297": [ + { + "before_scalar": 10097, + "event": 10393, + "private": false, + "rank": 1, + "source": 3, + "target": 17 + }, + { + "before_scalar": 10140, + "event": 10459, + "private": false, + "rank": 1, + "source": 17, + "target": 335 + }, + { + "before_scalar": 12670, + "event": 14477, + "private": false, + "rank": 1, + "source": 335, + "target": 720 + }, + { + "before_scalar": 13716, + "event": 16765, + "private": false, + "rank": 1, + "source": 720, + "target": 234 + }, + { + "before_scalar": 14296, + "event": 17719, + "private": false, + "rank": 5, + "source": 234, + "target": 127 + } + ], + "303": [ + { + "before_scalar": 10140, + "event": 10460, + "private": false, + "rank": 2, + "source": 3, + "target": 335 + }, + { + "before_scalar": 12672, + "event": 14482, + "private": false, + "rank": 1, + "source": 335, + "target": 722 + }, + { + "before_scalar": 12800, + "event": 14795, + "private": false, + "rank": 3, + "source": 722, + "target": 778 + }, + { + "before_scalar": 13086, + "event": 15550, + "private": false, + "rank": 1, + "source": 778, + "target": 927 + }, + { + "before_scalar": 14100, + "event": 17449, + "private": false, + "rank": 2, + "source": 927, + "target": 127 + } + ], + "319": [ + { + "before_scalar": 10257, + "event": 10619, + "private": false, + "rank": 1, + "source": 3, + "target": 32 + }, + { + "before_scalar": 10294, + "event": 10678, + "private": false, + "rank": 1, + "source": 32, + "target": 355 + }, + { + "before_scalar": 12485, + "event": 13982, + "private": false, + "rank": 1, + "source": 355, + "target": 617 + }, + { + "before_scalar": 12686, + "event": 14516, + "private": false, + "rank": 1, + "source": 617, + "target": 728 + }, + { + "before_scalar": 12795, + "event": 14782, + "private": false, + "rank": 2, + "source": 728, + "target": 775 + }, + { + "before_scalar": 13062, + "event": 15478, + "private": false, + "rank": 1, + "source": 775, + "target": 915 + }, + { + "before_scalar": 14097, + "event": 17442, + "private": false, + "rank": 2, + "source": 915, + "target": 127 + } + ], + "320": [ + { + "before_scalar": 10396, + "event": 10807, + "private": false, + "rank": 1, + "source": 3, + "target": 45 + }, + { + "before_scalar": 10430, + "event": 10857, + "private": false, + "rank": 1, + "source": 45, + "target": 366 + }, + { + "before_scalar": 10453, + "event": 10903, + "private": false, + "rank": 1, + "source": 366, + "target": 376 + }, + { + "before_scalar": 10465, + "event": 10930, + "private": false, + "rank": 1, + "source": 376, + "target": 237 + }, + { + "before_scalar": 11665, + "event": 12609, + "private": false, + "rank": 4, + "source": 237, + "target": 517 + }, + { + "before_scalar": 16057, + "event": 19597, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "336": [ + { + "before_scalar": 10550, + "event": 11021, + "private": false, + "rank": 1, + "source": 3, + "target": 6 + }, + { + "before_scalar": 10584, + "event": 11071, + "private": false, + "rank": 1, + "source": 6, + "target": 384 + }, + { + "before_scalar": 10607, + "event": 11117, + "private": false, + "rank": 1, + "source": 384, + "target": 394 + }, + { + "before_scalar": 10619, + "event": 11144, + "private": false, + "rank": 1, + "source": 394, + "target": 240 + }, + { + "before_scalar": 11672, + "event": 12624, + "private": false, + "rank": 4, + "source": 240, + "target": 518 + }, + { + "before_scalar": 18312, + "event": 21921, + "private": false, + "rank": 1, + "source": 518, + "target": 127 + } + ], + "352": [ + { + "before_scalar": 10704, + "event": 11235, + "private": false, + "rank": 1, + "source": 3, + "target": 77 + }, + { + "before_scalar": 10738, + "event": 11287, + "private": false, + "rank": 1, + "source": 77, + "target": 402 + }, + { + "before_scalar": 10761, + "event": 11335, + "private": false, + "rank": 1, + "source": 402, + "target": 414 + }, + { + "before_scalar": 10773, + "event": 11362, + "private": false, + "rank": 1, + "source": 414, + "target": 242 + }, + { + "before_scalar": 11666, + "event": 12611, + "private": false, + "rank": 4, + "source": 242, + "target": 517 + }, + { + "before_scalar": 15739, + "event": 19268, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "368": [ + { + "before_scalar": 10858, + "event": 11453, + "private": false, + "rank": 1, + "source": 3, + "target": 74 + }, + { + "before_scalar": 10892, + "event": 11503, + "private": false, + "rank": 1, + "source": 74, + "target": 422 + }, + { + "before_scalar": 10915, + "event": 11549, + "private": false, + "rank": 1, + "source": 422, + "target": 432 + }, + { + "before_scalar": 10927, + "event": 11576, + "private": false, + "rank": 1, + "source": 432, + "target": 243 + }, + { + "before_scalar": 11667, + "event": 12613, + "private": false, + "rank": 4, + "source": 243, + "target": 517 + }, + { + "before_scalar": 16613, + "event": 20180, + "private": false, + "rank": 1, + "source": 517, + "target": 127 + } + ], + "384": [ + { + "before_scalar": 11012, + "event": 11667, + "private": false, + "rank": 1, + "source": 3, + "target": 63 + }, + { + "before_scalar": 11046, + "event": 11719, + "private": false, + "rank": 1, + "source": 63, + "target": 440 + }, + { + "before_scalar": 11069, + "event": 11767, + "private": false, + "rank": 1, + "source": 440, + "target": 452 + }, + { + "before_scalar": 11081, + "event": 11794, + "private": false, + "rank": 1, + "source": 452, + "target": 244 + }, + { + "before_scalar": 11673, + "event": 12626, + "private": false, + "rank": 4, + "source": 244, + "target": 518 + }, + { + "before_scalar": 15601, + "event": 19121, + "private": false, + "rank": 1, + "source": 518, + "target": 127 + } + ], + "612": [ + { + "before_scalar": 11962, + "event": 13077, + "private": false, + "rank": 4, + "source": 112, + "target": 115 + }, + { + "before_scalar": 12003, + "event": 13167, + "private": false, + "rank": 1, + "source": 115, + "target": 556 + }, + { + "before_scalar": 12010, + "event": 13181, + "private": false, + "rank": 1, + "source": 556, + "target": 560 + }, + { + "before_scalar": 12012, + "event": 13184, + "private": false, + "rank": 1, + "source": 560, + "target": 559 + }, + { + "before_scalar": 14133, + "event": 17501, + "private": false, + "rank": 1, + "source": 559, + "target": 127 + } + ], + "692": [ + { + "before_scalar": 12368, + "event": 13810, + "private": false, + "rank": 3, + "source": 112, + "target": 125 + }, + { + "before_scalar": 13016, + "event": 15350, + "private": false, + "rank": 2, + "source": 125, + "target": 893 + }, + { + "before_scalar": 13643, + "event": 16597, + "private": false, + "rank": 1, + "source": 893, + "target": 1020 + }, + { + "before_scalar": 13646, + "event": 16602, + "private": false, + "rank": 1, + "source": 1020, + "target": 166 + }, + { + "before_scalar": 14183, + "event": 17571, + "private": false, + "rank": 1, + "source": 166, + "target": 127 + } + ] + } + } +} diff --git a/research/p104-joint-contact/funding-peer/inputs/local.json b/research/p104-joint-contact/funding-peer/inputs/local.json new file mode 100644 index 0000000000..b85ce258a0 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/local.json @@ -0,0 +1,24 @@ +{ + "endpoint_coefficients": 552049, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "owned_lifetimes": 8, + "paid": { + "1": 2430, + "2": 554, + "3": 390, + "4": 111, + "5": 108, + "6": 17, + "7": 13, + "9": 1 + }, + "peak_owned_fields": 1, + "public_inputs": 735, + "real_scalar_allowance": 217428 +} diff --git a/research/p104-joint-contact/funding-peer/inputs/native.json b/research/p104-joint-contact/funding-peer/inputs/native.json new file mode 100644 index 0000000000..2cb8421120 --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/native.json @@ -0,0 +1,15 @@ +{ + "distinct_maps": 2979, + "helper_normalizers": 1054, + "helpers": { + "4": 51, + "5": 36, + "7": 24, + "8": 122, + "9": 294 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "f7dac0d38942f0b02ad21c166281aeed704bc133421843f2b0ededaaf654e4a9", + "wrong_phase_rejected": true +} diff --git a/research/p104-joint-contact/funding-peer/inputs/physical.json b/research/p104-joint-contact/funding-peer/inputs/physical.json new file mode 100644 index 0000000000..e8f5aa076b --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/physical.json @@ -0,0 +1,48 @@ +{ + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208, + "145": 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 + ] +} diff --git a/research/p104-joint-contact/funding-peer/inputs/pr5545-source-closure.tar.gz b/research/p104-joint-contact/funding-peer/inputs/pr5545-source-closure.tar.gz new file mode 100644 index 0000000000..3084088544 Binary files /dev/null and b/research/p104-joint-contact/funding-peer/inputs/pr5545-source-closure.tar.gz differ diff --git a/research/p104-joint-contact/funding-peer/inputs/predecessor_pricing.py b/research/p104-joint-contact/funding-peer/inputs/predecessor_pricing.py new file mode 100644 index 0000000000..c88c425a2f --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/predecessor_pricing.py @@ -0,0 +1,154 @@ +"""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 PR5544 for the H1+H5 to H6 contact change. +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('.00304117'), Q('.003041171') +PREVIOUS = Q('.00304057') + + +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()) == 12814 and sum(paid.values()) == 69912, '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) + 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 selected kappa') + t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18 + 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**10),Q(97,100) + 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),1000 + 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') + 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':'.00304117','previous_open_pr5544':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA],'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, + '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':1, + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-joint-contact/funding-peer/inputs/successor_pricing.py b/research/p104-joint-contact/funding-peer/inputs/successor_pricing.py new file mode 100644 index 0000000000..ef78de99ff --- /dev/null +++ b/research/p104-joint-contact/funding-peer/inputs/successor_pricing.py @@ -0,0 +1,156 @@ +"""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 prepared for thu-nmrc with substantial OpenAI Codex assistance. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00304153'), Q('.0030415305') +PREVIOUS = Q('.00304117') + + +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()) == 12814 and sum(paid.values()) == 69912, '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) + 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 selected kappa') + t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18 + 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**10),Q(97,100) + 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),1000 + 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') + 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':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA],'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, + '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':1, + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-joint-contact/funding_review.py b/research/p104-joint-contact/funding_review.py new file mode 100644 index 0000000000..0d518232b3 --- /dev/null +++ b/research/p104-joint-contact/funding_review.py @@ -0,0 +1,20 @@ +"""Bind the separate rational funding audit to this publication's bytes. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0. +""" +from hashlib import sha256 +from pathlib import Path +import gzip,importlib.util,json,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +P=HERE/'funding-peer' +spec=importlib.util.spec_from_file_location('independent_p104_funding',P/'check.py') +M=importlib.util.module_from_spec(spec);spec.loader.exec_module(M) +result=json.loads(json.dumps(M.calculate(),sort_keys=True)) +M.need(result==json.loads((P/'RECEIPT.json').read_bytes()),'Frozen independent funding review') +for name,retained in [('RESULT.json','PUBLIC-RESULT.json'),('SOURCES.json','SOURCES.json')]: + M.need(json.loads((HERE/name).read_bytes())==M.read(retained),'Current publication '+name) +M.need(json.loads(gzip.decompress((HERE/'WORD.json.gz').read_bytes()))==json.loads(gzip.decompress((P/'inputs/PUBLIC-WORD.json.gz').read_bytes())),'Current publication WORD') +M.need((HERE/'pricing.py').read_bytes()==(P/'inputs/successor_pricing.py').read_bytes(),'Current publication pricing source') +M.need((HERE/'inputs/pr5545-source-closure.tar.gz').read_bytes()==(P/'inputs/pr5545-source-closure.tar.gz').read_bytes(),'Current publication retained source') +print('PASS_PUBLIC_P104_INDEPENDENT_FUNDING',sha256(json.dumps(result,sort_keys=True,separators=(',',':')).encode()).hexdigest()) diff --git a/research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz b/research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz new file mode 100644 index 0000000000..3084088544 Binary files /dev/null and b/research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz differ diff --git a/research/p104-joint-contact/native-peer/FILES.sha256 b/research/p104-joint-contact/native-peer/FILES.sha256 new file mode 100644 index 0000000000..a52aa1b686 --- /dev/null +++ b/research/p104-joint-contact/native-peer/FILES.sha256 @@ -0,0 +1,23 @@ +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 LICENSE +a95a66ae49c85374f2027fa7c02d4b4667d4cbdb982dea546b4d8cb55e9d23dd MAPS-PROGRAM.json +85f2af6131d8745e211ed1b931dfd57ad020d83d5f003b723d5785abaac4c82a PROOF.md +5b820f40f32eff2c3b58b913b4a727dd6a4d1e1ceb0b8b84295040bfe943bc45 README.md +3072df5959313e78c66bb80cd0f7df6d0d36ac9c7e03c75cd07fa4074178b00d RESULT.json +6d0dc53df5a896abecd3ac5a00e966234ed7bcf5433080d661aca359493a6ef6 inputs/FETCH-PINS.json +1fe25628346de8630f1f4dc01ab97e4676641303fb1755d4c1e810ac681ff72e inputs/INPUT-PINS.json +0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76 inputs/PR5545-EXPORT.json +b7b0ff6f42bd47244a1181eef3001467dc49fb8f97a3a31c0728bf1b3813ac85 inputs/PR5548-CAPSULE-INVENTORY.json +f188b0463b96701890c66e8641c399d21ab435d49e3495e0065c38a0bbd1d2a9 inputs/PR5548-NATIVE-PROOF.md +0a1f431edc8c65be2f6bcb7220c55fabf8be68dcc710c97a4e0428952c138ffb inputs/PR5548.json +acc69173db12be2c07051c8e8bd51284b3ea018ae850b2c2a4c3c7edfe9bfdc5 inputs/PR5550.json +48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446 inputs/PUBLIC-WORD.json.gz +a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d inputs/SOURCE-WORD.json.gz +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 inputs/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 inputs/native_verify.py +43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d inputs/pr5548_dense_check.py +e723295fbe75aadb43b0df0412f1844038fab77a2cda81bd0f882b0a163991c9 run.py +8363d7cdc111c5b66836970ef82d5607d4ec70f33da86c8278c9f059b9c48154 verification/REPLAY.json +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 verification/normal.stderr.txt +447bcc2acadeda00814bb067c6c703e1351ebdcbb3cf3a834f2cda3a6e75e5e0 verification/normal.stdout.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 verification/optimized.stderr.txt +447bcc2acadeda00814bb067c6c703e1351ebdcbb3cf3a834f2cda3a6e75e5e0 verification/optimized.stdout.txt diff --git a/research/p104-joint-contact/native-peer/LICENSE b/research/p104-joint-contact/native-peer/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-joint-contact/native-peer/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-joint-contact/native-peer/MAPS-PROGRAM.json b/research/p104-joint-contact/native-peer/MAPS-PROGRAM.json new file mode 100644 index 0000000000..ac297e9e76 --- /dev/null +++ b/research/p104-joint-contact/native-peer/MAPS-PROGRAM.json @@ -0,0 +1,1584 @@ +[ + { + "actual_literal": [ + [ + "D", + [ + 307, + 305, + 0, + 0, + 307, + 19, + 0, + 0, + 19 + ], + [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 258, + 19, + 289, + 34, + 4, + 8, + 304, + 64, + 128 + ] + ], + [ + "X", + 0 + ], + [ + "phase", + 0 + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 6, + 11, + 16, + 32, + 66, + 3, + 128, + 256, + 1 + ] + ], + [ + "X", + 0 + ], + [ + "phase", + 0 + ] + ], + "expected_literal": [ + [ + "D", + [ + 128, + 0, + 0, + 0, + 128, + 0, + 0, + 17, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 128, + 129, + 2, + 4, + 8, + 144, + 32, + 64, + 256 + ] + ], + [ + "C", + 1, + -1 + ], + [ + "P", + [ + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 1, + 256 + ] + ], + [ + "D", + [ + 128, + 0, + 0, + 0, + 128, + 0, + 0, + 17, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "D", + [ + 416, + 32, + 0, + 0, + 416, + 51, + 0, + 17, + 17 + ], + [ + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 32, + 128, + 256, + 417, + 34, + 4, + 8, + 432, + 64 + ] + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "P", + [ + 15, + 17, + 32, + 64, + 135, + 1, + 256, + 2, + 4 + ] + ], + [ + "D", + [ + 416, + 32, + 0, + 0, + 416, + 51, + 0, + 17, + 17 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ] + ] + ], + "pair": [ + 17, + 720 + ], + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 32, + 66, + 3, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 258, + 19, + 289, + 34, + 4, + 8, + 304, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 307, + 305, + 0, + 0, + 307, + 19, + 0, + 0, + 19 + ] + } + } + }, + { + "actual_literal": [ + [ + "D", + [ + 34, + 111, + 286, + 286, + 316, + 19, + 322, + 0, + 348 + ], + [ + 0, + 3, + 1, + 1, + 1, + 2, + 3, + 0, + 3 + ] + ], + [ + "P", + [ + 13, + 348, + 335, + 353, + 290, + 260, + 264, + 112, + 128 + ] + ], + [ + "X", + 4 + ], + [ + "phase", + 1 + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "D", + [ + 1, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 13, + 20, + 39, + 71, + 130, + 3, + 1, + 256, + 7 + ] + ], + [ + "X", + 0 + ], + [ + "phase", + 0 + ] + ], + "expected_literal": [ + [ + "D", + [ + 128, + 0, + 0, + 0, + 128, + 0, + 0, + 17, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 128, + 129, + 2, + 4, + 8, + 144, + 32, + 64, + 256 + ] + ], + [ + "C", + 1, + -1 + ], + [ + "P", + [ + 3, + 4, + 8, + 16, + 33, + 64, + 128, + 1, + 256 + ] + ], + [ + "D", + [ + 128, + 0, + 0, + 0, + 128, + 0, + 0, + 17, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "D", + [ + 480, + 288, + 256, + 256, + 224, + 51, + 273, + 273, + 207 + ], + [ + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 32, + 64, + 128, + 256, + 481, + 290, + 260, + 264, + 240 + ] + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "C", + 8, + 1 + ], + [ + "P", + [ + 31, + 41, + 72, + 136, + 263, + 1, + 2, + 4, + 8 + ] + ], + [ + "D", + [ + 480, + 288, + 256, + 256, + 224, + 51, + 273, + 273, + 207 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ] + ] + ], + "pair": [ + 17, + 782 + ], + "rank": 3, + "recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 20, + 39, + 71, + 130, + 3, + 1, + 256, + 7 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 1, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 3, + "right": { + "linear_Z4": [ + 0, + 3, + 1, + 1, + 1, + 2, + 3, + 0, + 3 + ], + "matrix_rows": [ + 13, + 348, + 335, + 353, + 290, + 260, + 264, + 112, + 128 + ], + "offset": 4, + "phase": 1, + "quadratic_rows": [ + 34, + 111, + 286, + 286, + 316, + 19, + 322, + 0, + 348 + ] + } + } + }, + { + "actual_literal": [ + [ + "D", + [ + 282, + 429, + 266, + 287, + 281, + 258, + 0, + 258, + 447 + ], + [ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1 + ] + ], + [ + "P", + [ + 420, + 447, + 441, + 413, + 317, + 445, + 16, + 8, + 64 + ] + ], + [ + "X", + 1 + ], + [ + "phase", + 1 + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "C", + 8, + 1 + ], + [ + "C", + 16, + 1 + ], + [ + "D", + [ + 24, + 28, + 26, + 31, + 31, + 0, + 0, + 0, + 0 + ], + [ + 2, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 62, + 66, + 133, + 5, + 2, + 9, + 256, + 17, + 1 + ] + ], + [ + "X", + 0 + ], + [ + "phase", + 0 + ] + ], + "expected_literal": [ + [ + "D", + [ + 88, + 16, + 8, + 85, + 75, + 0, + 89, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 0 + ] + ], + [ + "P", + [ + 8, + 16, + 64, + 89, + 18, + 12, + 32, + 128, + 256 + ] + ], + [ + "C", + 4, + -1 + ], + [ + "C", + 2, + -1 + ], + [ + "C", + 1, + -1 + ], + [ + "P", + [ + 15, + 18, + 33, + 1, + 2, + 64, + 4, + 128, + 256 + ] + ], + [ + "D", + [ + 88, + 16, + 8, + 85, + 75, + 0, + 89, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ] + ], + [ + "D", + [ + 500, + 0, + 501, + 0, + 501, + 501, + 501, + 501, + 501 + ], + [ + 0, + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 3 + ] + ], + [ + "P", + [ + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256, + 501 + ] + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "C", + 8, + 1 + ], + [ + "C", + 16, + 1 + ], + [ + "C", + 32, + 1 + ], + [ + "C", + 64, + 1 + ], + [ + "C", + 128, + 1 + ], + [ + "P", + [ + 506, + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128 + ] + ], + [ + "D", + [ + 500, + 0, + 501, + 0, + 501, + 501, + 501, + 501, + 501 + ], + [ + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + ] + ], + "pair": [ + 615, + 207 + ], + "rank": 5, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 62, + 66, + 133, + 5, + 2, + 9, + 256, + 17, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 24, + 28, + 26, + 31, + 31, + 0, + 0, + 0, + 0 + ] + }, + "rank": 5, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 420, + 447, + 441, + 413, + 317, + 445, + 16, + 8, + 64 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 282, + 429, + 266, + 287, + 281, + 258, + 0, + 258, + 447 + ] + } + } + }, + { + "actual_literal": [ + [ + "D", + [ + 266, + 17, + 0, + 273, + 10, + 0, + 0, + 0, + 265 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1 + ] + ], + [ + "P", + [ + 259, + 265, + 257, + 272, + 276, + 16, + 288, + 320, + 384 + ] + ], + [ + "X", + 31 + ], + [ + "phase", + 3 + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "D", + [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + "P", + [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ] + ], + [ + "X", + 0 + ], + [ + "phase", + 0 + ] + ], + "expected_literal": [ + [ + "D", + [ + 500, + 484, + 19, + 496, + 13, + 491, + 491, + 491, + 491 + ], + [ + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 3, + 3 + ] + ], + [ + "P", + [ + 4, + 16, + 32, + 64, + 128, + 256, + 501, + 486, + 504 + ] + ], + [ + "C", + 32, + -1 + ], + [ + "C", + 16, + -1 + ], + [ + "C", + 8, + -1 + ], + [ + "C", + 4, + -1 + ], + [ + "C", + 2, + -1 + ], + [ + "C", + 1, + -1 + ], + [ + "P", + [ + 127, + 189, + 1, + 318, + 2, + 4, + 8, + 16, + 32 + ] + ], + [ + "D", + [ + 500, + 484, + 19, + 496, + 13, + 491, + 491, + 491, + 491 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ] + ], + [ + "D", + [ + 500, + 0, + 501, + 0, + 501, + 501, + 501, + 501, + 501 + ], + [ + 0, + 0, + 3, + 0, + 3, + 3, + 3, + 3, + 3 + ] + ], + [ + "P", + [ + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256, + 501 + ] + ], + [ + "C", + 1, + 1 + ], + [ + "C", + 2, + 1 + ], + [ + "C", + 4, + 1 + ], + [ + "C", + 8, + 1 + ], + [ + "C", + 16, + 1 + ], + [ + "C", + 32, + 1 + ], + [ + "C", + 64, + 1 + ], + [ + "C", + 128, + 1 + ], + [ + "P", + [ + 506, + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128 + ] + ], + [ + "D", + [ + 500, + 0, + 501, + 0, + 501, + 501, + 501, + 501, + 501 + ], + [ + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + ] + ], + "pair": [ + 775, + 207 + ], + "rank": 2, + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 9, + 17, + 34, + 2, + 67, + 131, + 259, + 3 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1 + ], + "matrix_rows": [ + 259, + 265, + 257, + 272, + 276, + 16, + 288, + 320, + 384 + ], + "offset": 31, + "phase": 3, + "quadratic_rows": [ + 266, + 17, + 0, + 273, + 10, + 0, + 0, + 0, + 265 + ] + } + } + } +] diff --git a/research/p104-joint-contact/native-peer/PROOF.md b/research/p104-joint-contact/native-peer/PROOF.md new file mode 100644 index 0000000000..44860697e7 --- /dev/null +++ b/research/p104-joint-contact/native-peer/PROOF.md @@ -0,0 +1,15 @@ +# Four exact interfaces and the positive-width implication + +For each added pair F->G, the expected base operator is the chronological circuit for Phi_F^{-1}, followed by Phi_G. The pinned compiler emits ordinary right and left monomials with a single positive rank-r child between them. The expected and emitted circuits are independently evaluated as 512-by-512 complex matrices. Every coordinate, including its sign and phase, agrees exactly. + +The arithmetic representation is a complete dense vector of Gaussian integer numerators with one denominator 2^d. P/X permute addresses; D and phase multiply by exact powers of i. A signed C_q uses + +``` +C_q^s = ((1+s i) I + (1-s i) X_q)/2, s in {+1,-1}. +``` + +The retained independent engine applies these formulas directly, without a vendor tableau/state matrix comparison. Canonical common powers of two are removed only at the column endpoint, so exact vector equality implies equality on every input vector. Each column has squared norm one and exactly 2^r nonzero coordinates, binding the stated rank to actual dense support under ordinary monomial boundaries. + +For a positive field width f, tensoring the proven base equality gives equality of the factorwise operators on all f digit columns. The base global phase i^theta tensors to i^(f theta); it is not dropped or replaced by i^theta. External owner ADD/SCALE coefficients occur once outside these tensor powers. When both fields have the same declared chart, transport intertwines these scalar operations. Therefore these four newly emitted chart transitions preserve the parent word's typed induction at every positive width, subject to the inherited implementation/recursive-service premises. + +This implication is only for the four added interfaces. It does not prove the old common interfaces, all-column native cost implementation, the whole physical caller or its raw inverse transpose, rounded machine work, erasure or final analytic recovery. The underlying compiler and literal source definitions are credited reused code. The arithmetic execution is the exact unchanged PR5548 implementation, reused to cover new pairs. diff --git a/research/p104-joint-contact/native-peer/README.md b/research/p104-joint-contact/native-peer/README.md new file mode 100644 index 0000000000..97f62a16b5 --- /dev/null +++ b/research/p104-joint-contact/native-peer/README.md @@ -0,0 +1,43 @@ +# Exact dense audit of the four added P104 MOVE maps + +All 512 columns of each of the four new actual MOVE interfaces pass exact complex dyadic comparison, including absolute global phase. There are **1,048,576 complex entry comparisons per mode**. This is a focused delta audit, with no new construction, kappa, selected promotion or full-framework admission claim. + +The reviewed predecessor is PR5545 commit `18968423711fd902aaee1099979497d55603e1dc`; the reviewed successor is PR5551 commit `79072da5404a01056df2af2e4132324b01c72366`. Both actual words, all imported source bytes, source inventories, PR scope snapshots and input hashes are retained locally. Runtime requires Python 3.12 and its standard library, with no Git, network, external worktree or author native evaluator. + +``` +python3.12 run.py +python3.12 -O run.py +``` + +Default execution is read-only and compares both saved scientific artifacts. `--write` is explicit author mode. `RESULT.json` inventories every added/removed actual frame pair, its bases, rank, field roles and event versions; it also records every changed multiplicity among otherwise common maps. `MAPS-PROGRAM.json` emits the four literal recipes and their complete expected/actual circuits. + +## Exact delta + +| New pair | Rank | Actual successor event / role | +| --- | --- | --- | +| 17 -> 720 | 2 | 14477 / 297 | +| 17 -> 782 | 3 | 14807 / 152 | +| 615 -> 207 | 5 | 15477 / 198 | +| 775 -> 207 | 2 | 15478 / 319 | + +Each new pair occurs once. Distinct actual MOVE pairs change from 2,942 to 2,940, with 2,936 common pairs, four added pairs and six removed pairs. The six removed pairs are 3->335, 335->720, 335->782, 615->915, 775->915 and 915->127. Counting all changed multiplicities gives exactly `2H1 -3H2 +H3 -H4 +H5`; it is not obtained by counting distinct pairs alone. + +## Engine and checks + +This package reuses Chris R/Clear1nsight's independent dense arithmetic interpreter from [PR5548](https://github.com/CrocSwap/integer-mult-bounds/pull/5548), exact commit `b038f9d9b5cf0ce92184da909e57a3be476fc812`, unchanged SHA-256 `43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d`. Its dense-column/compiler/first-difference functions execute P, D, X, phase and signed positive/inverse C gates on complete integral real/imaginary vectors with a binary denominator. Neither vendor state interpreter nor vendor tableau is used for matrix comparison. This is credited reuse of that independent arithmetic implementation, not a new independently authored dense engine. + +The canonical Clifford compiler and literal chart/recipe descriptions are the byte-pinned PR5545 sources. The new comparison loop streams columns, compares every complex coordinate, checks exact column norm, measures support `2^rank` on every column, records absolute anchors and hashes the complete matrices. Source authentication precedes imports. + +For each new map, controls reject a global phase error invisible to signed Pauli tableaux, wrong child sign, wrong ordinary boundary and wrong declared rank. Two source-byte corruptions fail authentication. Normal/optimized agreement is reproducibility of the same implementation. + +## Relation to previous review + +[PR5548](https://github.com/CrocSwap/integer-mult-bounds/pull/5548) checked the older rank-1/5/6 maps among frames 739, 240 and 127, plus their route composition. None is one of these four added frame pairs. Its repeated-H5 ceiling concerns a different fixed edit family. + +[PR5550](https://github.com/CrocSwap/integer-mult-bounds/pull/5550) checked the earlier forward caller, target aliases, ordinary pass count and related target interfaces. It expressly retained the local all-input/all-width ABI and untouched paid-map foundation. Our local endpoint/chart ABI and helper targets remain the predecessor's, so replacement into the same caller is a conditional compositional argument. This four-map audit does not rerun or independently discharge that caller's full source foundation. + +The 2,936 common MOVE pairs, other native interfaces, full caller dual, erasure, precision/tape/storage, uniform compiler and analytic recovery remain outside this focused dense audit. The five framework assumptions remain. No independent human or proof-kernel acceptance is claimed. + +## Credit and license + +Ali Romman supplies PR5544/5545's construction, native interface, caller and price. Chris R/Clear1nsight supplies PR5548's new dense interpreter and prior audit. Retain Gareth Davidson, David Arias, Cinna Davis, Jacob Alan Sussman, zxv, Cao Yifan and all Clifford, native-review, geometry, COPY, precision and analytic source notices. New inventory, word binding and focused application prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0; LICENSE is retained. No public package has been edited by this audit. diff --git a/research/p104-joint-contact/native-peer/RESULT.json b/research/p104-joint-contact/native-peer/RESULT.json new file mode 100644 index 0000000000..f421d36900 --- /dev/null +++ b/research/p104-joint-contact/native-peer/RESULT.json @@ -0,0 +1,940 @@ +{ + "base_dimension": 512, + "complex_entry_comparisons": 1048576, + "controls": { + "17_to_720_wrong_boundary": { + "first_rejected_column": 0 + }, + "17_to_720_wrong_child_sign": { + "first_rejected_column": 0 + }, + "17_to_720_wrong_declared_rank": "REJECTED", + "17_to_720_wrong_global_phase": { + "first_rejected_column": 0, + "signed_tableau_unchanged": true + }, + "17_to_782_wrong_boundary": { + "first_rejected_column": 0 + }, + "17_to_782_wrong_child_sign": { + "first_rejected_column": 0 + }, + "17_to_782_wrong_declared_rank": "REJECTED", + "17_to_782_wrong_global_phase": { + "first_rejected_column": 0, + "signed_tableau_unchanged": true + }, + "615_to_207_wrong_boundary": { + "first_rejected_column": 0 + }, + "615_to_207_wrong_child_sign": { + "first_rejected_column": 0 + }, + "615_to_207_wrong_declared_rank": "REJECTED", + "615_to_207_wrong_global_phase": { + "first_rejected_column": 0, + "signed_tableau_unchanged": true + }, + "775_to_207_wrong_boundary": { + "first_rejected_column": 0 + }, + "775_to_207_wrong_child_sign": { + "first_rejected_column": 0 + }, + "775_to_207_wrong_declared_rank": "REJECTED", + "775_to_207_wrong_global_phase": { + "first_rejected_column": 0, + "signed_tableau_unchanged": true + } + }, + "coverage": { + "all_old_paid_foundation_checked": false, + "full_framework_admitted": false, + "new_kappa": null, + "previous_common_MOVE_pairs": 2936, + "whole_caller_replayed": false + }, + "engine": "Unmodified PR5548 compile_circuit/dense_column/first_difference; new streamed comparison also checks every column norm/support. No vendor state/tableau is used for matrix equality.", + "inventory": { + "PR5548_paid_pairs": [ + [ + 739, + 240 + ], + [ + 240, + 127 + ], + [ + 739, + 127 + ] + ], + "PR5548_pair_overlap": [], + "added": [ + { + "after": [ + { + "event": 14477, + "private": false, + "role": 297 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 145, + 273 + ], + "target_frame": 720 + }, + { + "after": [ + { + "event": 14807, + "private": false, + "role": 152 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 3, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 81, + 145, + 271 + ], + "target_frame": 782 + }, + { + "after": [ + { + "event": 15477, + "private": false, + "role": 198 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 5, + "source_basis": [ + 13, + 19, + 65 + ], + "source_frame": 615, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + }, + { + "after": [ + { + "event": 15478, + "private": false, + "role": 319 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 7, + 25, + 43, + 75, + 139, + 267 + ], + "source_frame": 775, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + } + ], + "after_distinct": 2940, + "all_changed_multiplicities": [ + { + "after": [ + { + "event": 10391, + "private": false, + "role": 296 + }, + { + "event": 10393, + "private": false, + "role": 297 + }, + { + "event": 10459, + "private": false, + "role": 303 + }, + { + "event": 13969, + "private": false, + "role": 152 + } + ], + "before": [ + { + "event": 10391, + "private": false, + "role": 296 + }, + { + "event": 10393, + "private": false, + "role": 297 + } + ], + "multiplicity_delta": 2, + "rank": 1, + "source_basis": [], + "source_frame": 3, + "target_basis": [ + 145 + ], + "target_frame": 17 + }, + { + "after": [], + "before": [ + { + "event": 10460, + "private": false, + "role": 303 + }, + { + "event": 13969, + "private": false, + "role": 152 + } + ], + "multiplicity_delta": -2, + "rank": 2, + "source_basis": [], + "source_frame": 3, + "target_basis": [ + 51, + 145 + ], + "target_frame": 335 + }, + { + "after": [ + { + "event": 14477, + "private": false, + "role": 297 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 145, + 273 + ], + "target_frame": 720 + }, + { + "after": [ + { + "event": 14807, + "private": false, + "role": 152 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 3, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 81, + 145, + 271 + ], + "target_frame": 782 + }, + { + "after": [ + { + "event": 16231, + "private": false, + "role": 205 + }, + { + "event": 17305, + "private": false, + "role": 653 + }, + { + "event": 17309, + "private": false, + "role": 655 + }, + { + "event": 17442, + "private": false, + "role": 319 + } + ], + "before": [ + { + "event": 17305, + "private": false, + "role": 653 + }, + { + "event": 17309, + "private": false, + "role": 655 + } + ], + "multiplicity_delta": 2, + "rank": 1, + "source_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "source_frame": 207, + "target_basis": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "target_frame": 127 + }, + { + "after": [], + "before": [ + { + "event": 14477, + "private": false, + "role": 297 + } + ], + "multiplicity_delta": -1, + "rank": 1, + "source_basis": [ + 51, + 145 + ], + "source_frame": 335, + "target_basis": [ + 51, + 145, + 273 + ], + "target_frame": 720 + }, + { + "after": [], + "before": [ + { + "event": 14807, + "private": false, + "role": 152 + } + ], + "multiplicity_delta": -1, + "rank": 2, + "source_basis": [ + 51, + 145 + ], + "source_frame": 335, + "target_basis": [ + 51, + 81, + 145, + 271 + ], + "target_frame": 782 + }, + { + "after": [ + { + "event": 15477, + "private": false, + "role": 198 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 5, + "source_basis": [ + 13, + 19, + 65 + ], + "source_frame": 615, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + }, + { + "after": [], + "before": [ + { + "event": 15477, + "private": false, + "role": 198 + } + ], + "multiplicity_delta": -1, + "rank": 4, + "source_basis": [ + 13, + 19, + 65 + ], + "source_frame": 615, + "target_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "target_frame": 915 + }, + { + "after": [ + { + "event": 15478, + "private": false, + "role": 319 + } + ], + "before": [], + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 7, + 25, + 43, + 75, + 139, + 267 + ], + "source_frame": 775, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + }, + { + "after": [], + "before": [ + { + "event": 15478, + "private": false, + "role": 319 + } + ], + "multiplicity_delta": -1, + "rank": 1, + "source_basis": [ + 7, + 25, + 43, + 75, + 139, + 267 + ], + "source_frame": 775, + "target_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "target_frame": 915 + }, + { + "after": [], + "before": [ + { + "event": 16231, + "private": false, + "role": 205 + }, + { + "event": 17442, + "private": false, + "role": 319 + } + ], + "multiplicity_delta": -2, + "rank": 2, + "source_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "source_frame": 915, + "target_basis": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "target_frame": 127 + } + ], + "before_distinct": 2942, + "common_distinct": 2936, + "local_paid_delta": { + "1": 2, + "2": -3, + "3": 1, + "4": -1, + "5": 1 + }, + "removed": [ + { + "after": [], + "before": [ + { + "event": 10460, + "private": false, + "role": 303 + }, + { + "event": 13969, + "private": false, + "role": 152 + } + ], + "multiplicity_delta": -2, + "rank": 2, + "source_basis": [], + "source_frame": 3, + "target_basis": [ + 51, + 145 + ], + "target_frame": 335 + }, + { + "after": [], + "before": [ + { + "event": 14477, + "private": false, + "role": 297 + } + ], + "multiplicity_delta": -1, + "rank": 1, + "source_basis": [ + 51, + 145 + ], + "source_frame": 335, + "target_basis": [ + 51, + 145, + 273 + ], + "target_frame": 720 + }, + { + "after": [], + "before": [ + { + "event": 14807, + "private": false, + "role": 152 + } + ], + "multiplicity_delta": -1, + "rank": 2, + "source_basis": [ + 51, + 145 + ], + "source_frame": 335, + "target_basis": [ + 51, + 81, + 145, + 271 + ], + "target_frame": 782 + }, + { + "after": [], + "before": [ + { + "event": 15477, + "private": false, + "role": 198 + } + ], + "multiplicity_delta": -1, + "rank": 4, + "source_basis": [ + 13, + 19, + 65 + ], + "source_frame": 615, + "target_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "target_frame": 915 + }, + { + "after": [], + "before": [ + { + "event": 15478, + "private": false, + "role": 319 + } + ], + "multiplicity_delta": -1, + "rank": 1, + "source_basis": [ + 7, + 25, + 43, + 75, + 139, + 267 + ], + "source_frame": 775, + "target_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "target_frame": 915 + }, + { + "after": [], + "before": [ + { + "event": 16231, + "private": false, + "role": 205 + }, + { + "event": 17442, + "private": false, + "role": 319 + } + ], + "multiplicity_delta": -2, + "rank": 2, + "source_basis": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "source_frame": 915, + "target_basis": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "target_frame": 127 + } + ], + "total_MOVE_count_after": 3624, + "total_MOVE_count_before": 3624 + }, + "limits": [ + "Uses credited source compiler and literal circuit descriptions; dense arithmetic interpreter is credited reuse from PR5548, not a new independent arithmetic implementation.", + "Does not independently close the old paid-map foundation, all-width native implementation premise, full caller dual, erasure, precision/tape/storage, uniform compiler or analytic recovery.", + "Normal/optimized equality is reproducibility, not a second implementation or human/proof-kernel acceptance." + ], + "maps": [ + { + "absolute_anchor": { + "column": 0, + "denominator_exponent": 1, + "imag": 1, + "real": 0, + "row": 0 + }, + "actual_gate_count": 10, + "after": [ + { + "event": 14477, + "private": false, + "role": 297 + } + ], + "before": [], + "column_support_histogram": { + "4": 512 + }, + "columns": 512, + "complex_entry_comparisons": 262144, + "expected_gate_count": 12, + "matrix_sha256": "d66b2ee19ea260d88a6bd5af72fa123996265a586f09a9d48b92b4354e6620f1", + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 145, + 273 + ], + "target_frame": 720 + }, + { + "absolute_anchor": { + "column": 0, + "denominator_exponent": 2, + "imag": 1, + "real": -1, + "row": 0 + }, + "actual_gate_count": 11, + "after": [ + { + "event": 14807, + "private": false, + "role": 152 + } + ], + "before": [], + "column_support_histogram": { + "8": 512 + }, + "columns": 512, + "complex_entry_comparisons": 262144, + "expected_gate_count": 13, + "matrix_sha256": "b5cc0ee289d89bc3d9166e32463e21d471ad48402f2242e1a808e378c2aa176f", + "multiplicity_delta": 1, + "rank": 3, + "source_basis": [ + 145 + ], + "source_frame": 17, + "target_basis": [ + 51, + 81, + 145, + 271 + ], + "target_frame": 782 + }, + { + "absolute_anchor": { + "column": 0, + "denominator_exponent": 3, + "imag": -1, + "real": -1, + "row": 0 + }, + "actual_gate_count": 13, + "after": [ + { + "event": 15477, + "private": false, + "role": 198 + } + ], + "before": [], + "column_support_histogram": { + "32": 512 + }, + "columns": 512, + "complex_entry_comparisons": 262144, + "expected_gate_count": 19, + "matrix_sha256": "0ad24724dd057a94873cd6038daf9e9075431467fbdf1e7a8ab2713f875feff7", + "multiplicity_delta": 1, + "rank": 5, + "source_basis": [ + 13, + 19, + 65 + ], + "source_frame": 615, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + }, + { + "absolute_anchor": { + "column": 0, + "denominator_exponent": 1, + "imag": 0, + "real": -1, + "row": 7 + }, + "actual_gate_count": 10, + "after": [ + { + "event": 15478, + "private": false, + "role": 319 + } + ], + "before": [], + "column_support_histogram": { + "4": 512 + }, + "columns": 512, + "complex_entry_comparisons": 262144, + "expected_gate_count": 22, + "matrix_sha256": "59fa18f84d0730dad0b1c697cee903b3c31f323abcfbc93a03b26886f424906f", + "multiplicity_delta": 1, + "rank": 2, + "source_basis": [ + 7, + 25, + 43, + 75, + 139, + 267 + ], + "source_frame": 775, + "target_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "target_frame": 207 + } + ], + "positive_width_implication": "Each exact base chart equality tensors factorwise; absolute phase i^theta lifts as i^(f theta), scalars remain exterior. This covers four added map interfaces only.", + "reviewed_public_commit": "79072da5404a01056df2af2e4132324b01c72366", + "reviewed_source_commit": "18968423711fd902aaee1099979497d55603e1dc", + "schema": "p104-added-maps-dense-audit/1", + "source_authentication_controls": 2, + "source_pins": { + "FETCH-PINS.json": "6d0dc53df5a896abecd3ac5a00e966234ed7bcf5433080d661aca359493a6ef6", + "PR5545-EXPORT.json": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "PR5548-CAPSULE-INVENTORY.json": "b7b0ff6f42bd47244a1181eef3001467dc49fb8f97a3a31c0728bf1b3813ac85", + "PR5548-NATIVE-PROOF.md": "f188b0463b96701890c66e8641c399d21ab435d49e3495e0065c38a0bbd1d2a9", + "PR5548.json": "0a1f431edc8c65be2f6bcb7220c55fabf8be68dcc710c97a4e0428952c138ffb", + "PR5550.json": "acc69173db12be2c07051c8e8bd51284b3ea018ae850b2c2a4c3c7edfe9bfdc5", + "PUBLIC-WORD.json.gz": "48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446", + "SOURCE-WORD.json.gz": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d", + "clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "pr5548_dense_check.py": "43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d" + }, + "status": "PASS_FOUR_NEW_MAPS_ONLY" +} diff --git a/research/p104-joint-contact/native-peer/inputs/FETCH-PINS.json b/research/p104-joint-contact/native-peer/inputs/FETCH-PINS.json new file mode 100644 index 0000000000..6145bc46e4 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/FETCH-PINS.json @@ -0,0 +1,20 @@ +{ + "PR5548-CAPSULE-INVENTORY.json": { + "commit": "b038f9d9b5cf0ce92184da909e57a3be476fc812", + "git_blob": "82ea6df8300198401ccd67bc586847e62ba9605a", + "path": "research/p104-contact-independent-audit/CAPSULE-INVENTORY.json", + "sha256": "b7b0ff6f42bd47244a1181eef3001467dc49fb8f97a3a31c0728bf1b3813ac85" + }, + "PR5548-NATIVE-PROOF.md": { + "commit": "b038f9d9b5cf0ce92184da909e57a3be476fc812", + "git_blob": "d968f3c93a1ffd6d9f33d17a3471af760b7af7b0", + "path": "research/p104-contact-independent-audit/NATIVE-PROOF.md", + "sha256": "f188b0463b96701890c66e8641c399d21ab435d49e3495e0065c38a0bbd1d2a9" + }, + "pr5548_dense_check.py": { + "commit": "b038f9d9b5cf0ce92184da909e57a3be476fc812", + "git_blob": "e7e663bebaf13f44c95fb8eb118b472cf377e137", + "path": "research/p104-contact-independent-audit/capsule/outputs/p104-native-contact-audit-20261025/check.py", + "sha256": "43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d" + } +} diff --git a/research/p104-joint-contact/native-peer/inputs/INPUT-PINS.json b/research/p104-joint-contact/native-peer/inputs/INPUT-PINS.json new file mode 100644 index 0000000000..c87b71b856 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/INPUT-PINS.json @@ -0,0 +1,21 @@ +{ + "PR5545_export_manifest_sha256": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "PR5548_dense_module_sha256": "43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d", + "files": { + "FETCH-PINS.json": "6d0dc53df5a896abecd3ac5a00e966234ed7bcf5433080d661aca359493a6ef6", + "PR5545-EXPORT.json": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76", + "PR5548-CAPSULE-INVENTORY.json": "b7b0ff6f42bd47244a1181eef3001467dc49fb8f97a3a31c0728bf1b3813ac85", + "PR5548-NATIVE-PROOF.md": "f188b0463b96701890c66e8641c399d21ab435d49e3495e0065c38a0bbd1d2a9", + "PR5548.json": "0a1f431edc8c65be2f6bcb7220c55fabf8be68dcc710c97a4e0428952c138ffb", + "PR5550.json": "acc69173db12be2c07051c8e8bd51284b3ea018ae850b2c2a4c3c7edfe9bfdc5", + "PUBLIC-WORD.json.gz": "48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446", + "SOURCE-WORD.json.gz": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d", + "clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "pr5548_dense_check.py": "43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d" + }, + "public_word_git_blob": "c04a815c2662bcd0c48ce9c3067a0fe4a041573a", + "public_word_path": "research/p104-joint-contact/WORD.json.gz", + "reviewed_public_commit": "79072da5404a01056df2af2e4132324b01c72366", + "reviewed_source_commit": "18968423711fd902aaee1099979497d55603e1dc" +} diff --git a/research/p104-joint-contact/native-peer/inputs/PR5545-EXPORT.json b/research/p104-joint-contact/native-peer/inputs/PR5545-EXPORT.json new file mode 100644 index 0000000000..8941635631 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/PR5545-EXPORT.json @@ -0,0 +1,205 @@ +{ + "commit": "18968423711fd902aaee1099979497d55603e1dc", + "files": [ + { + "mode": 420, + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "size": 84805 + }, + { + "mode": 420, + "path": "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f", + "size": 358962 + }, + { + "mode": 420, + "path": "research/higher-moment-strictification/verify.py", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "size": 17152 + }, + { + "mode": 420, + "path": "research/joint-helper-lattice/CONTROLLER.json", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "size": 57924 + }, + { + "mode": 420, + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "size": 814141 + }, + { + "mode": 420, + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "size": 12298 + }, + { + "mode": 420, + "path": "research/p104-coalesced-private-reuse/RESULT.json", + "sha256": "580adb3de7037acc6f7e41cc186e8a210463afaa696d57892643d55acd0040c8", + "size": 31258 + }, + { + "mode": 420, + "path": "research/p104-coalesced-private-reuse/SOURCES.json", + "sha256": "232fc3ca3928acc704333def0b8391f94a8e8736ef045c1b5de5b396be37cdc2", + "size": 7844 + }, + { + "mode": 420, + "path": "research/p104-coalesced-private-reuse/compose.py", + "sha256": "9ac1c0e5ac26ed98976148ef9fd73ee58533533f9581c701deaf26ced899ae9e", + "size": 12063 + }, + { + "mode": 420, + "path": "research/p104-coalesced-private-reuse/predecessor2152.tar.gz", + "sha256": "67867369c99212184c13d75369811ea928c89dca0e004287a9dcf0b2c93bcdb8", + "size": 50448 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/PROOF.md", + "sha256": "1961e8b8be133cee19ec2523f6ba40da02905444a8c9601e97f66627b1129b32", + "size": 8756 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/README.md", + "sha256": "19fec538e0eae59eeef90099ab220bef820467272410533fc95ee6236f44c4cd", + "size": 4358 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/RESULT.json", + "sha256": "b1dc682a4d9db5a726fbdf5c05c081f3c9ff9816829e5d8c900db1904a1f98c1", + "size": 10803 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/SOURCES.json", + "sha256": "42a7f956bf450c15a92449e285bd2b355159cc99e78bc1d815a4b902221ab89f", + "size": 6152 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/TASK.json", + "sha256": "ae1aff13f641c94a977599c1946dd0ff678daae51aad83662aa7056626e0dee6", + "size": 6128 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/VALIDATION.md", + "sha256": "425948a055123fa8652e70b4b27b20ccc0588dfd4f8fa49405a35d1834c87901", + "size": 4525 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/VERIFY.json", + "sha256": "4543e838e81dff7cceb7f539a94eedbd891ed5330518e55e997ba93ec4f51356", + "size": 2301 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/WORD.json.gz", + "sha256": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d", + "size": 107042 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/construct.py", + "sha256": "b95eeb2c21c9e2d97d9a441483aa398e38eba65ecec57241bce77cd1234682d0", + "size": 1984 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/pricing.py", + "sha256": "f74461d08c1cfdb9d500ac4f0da11f1b2d66a149bb342145b9aab9df703017a9", + "size": 8880 + }, + { + "mode": 420, + "path": "research/p104-full-frame-contact/verify.py", + "sha256": "24074e4e954cf455b207ff346c7d983d51c06e1fa967747bc98e8f24f5bd1f80", + "size": 4627 + }, + { + "mode": 420, + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4", + "size": 22381 + }, + { + "mode": 420, + "path": "research/p104-native-channel/vendor/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "size": 6824 + }, + { + "mode": 420, + "path": "research/p104-native-channel/vendor/native_verify.py", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "size": 12323 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/CONTROLLER.json", + "sha256": "a84f6bbd547379597464e56c420cc665f96bc43a9a1351eed4b7cd0fce3cc4b9", + "size": 60013 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/RESULT.json", + "sha256": "03e9f8424b9166899d3ae3b188d9defb851162a3183ecab237fb783d78216782", + "size": 10650 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/WORD.json.gz", + "sha256": "e5e955d7c9d5ea5dfea49c0e093037df577aa43813dcad5427ebca41a4ad35ec", + "size": 107034 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/caller.py", + "sha256": "300d40043953e4f6aecfde8f2d1004b8ad6dc5a79ec3c7666c9908c2466c91c8", + "size": 10267 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/local.py", + "sha256": "878734dfd64c4b9d362d0ae476cc5c2a19fe93e48b7378763b23f3e0dd0a5a71", + "size": 12067 + }, + { + "mode": 420, + "path": "research/p104-productive-controller/price.py", + "sha256": "e46c1264c4acb037bae4df36ccdf3386980ef3d178aa7f0607dbd3f3333ed139", + "size": 8834 + }, + { + "mode": 420, + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "size": 11603 + }, + { + "mode": 420, + "path": "research/pr4359-p7-padding/native_inventory.py", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32", + "size": 15510 + }, + { + "mode": 420, + "path": "research/query-thinned-controllers/RESULT.json", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "size": 10237 + } + ], + "format": "research-package-export-v1", + "package": "research/p104-full-frame-contact" +} diff --git a/research/p104-joint-contact/native-peer/inputs/PR5548-CAPSULE-INVENTORY.json b/research/p104-joint-contact/native-peer/inputs/PR5548-CAPSULE-INVENTORY.json new file mode 100644 index 0000000000..82ea6df830 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/PR5548-CAPSULE-INVENTORY.json @@ -0,0 +1,34 @@ +{ + "schema": "byte-preserved-audit-capsule/v1", + "files": { + "expected/contact-ceiling.json": "3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608", + "expected/native.json": "34299df26387b69f1a89cc52d52cae3add51f4e12c0715e0de38d42fab302c9f", + "capsule/outputs/economic-sensitivity-feasibility-20261025/interval_math.py": "14f28d0358c11d55683984f1037c23d58f7d8c9d69b8e23503545b0519246ab4", + "capsule/outputs/p104-native-contact-audit-20261025/check.py": "43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d", + "capsule/outputs/p104-native-contact-audit-20261025/INPUTS.json": "ae975357dc858791d122579425525625b34039dca664be9a43e0738921dc3315", + "capsule/outputs/p104-contact-reassessment-20261025/check.py": "c4963f22cc862e9b75db01097968d56b3222f64ee796679b0b6ba810a8e6a19c", + "capsule/outputs/p104-contact-reassessment-20261025/RESULT-normal.json": "3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608", + "capsule/outputs/p104-contact-reassessment-20261025/PAIR-RECEIPT.json": "d9f284021cb5f2757b05cbf5f979f5ba7cf7372993d65a2e060002aca7841fa8", + "capsule/outputs/p104-contact-reassessment-20261025/INPUTS.json": "5c3061c48cfc2a408cafe3e23f1050db0cc529179758b918547e9ed06bd3147a", + "capsule/outputs/p104-native-contact-audit-20261025/sources/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "capsule/outputs/p104-native-contact-audit-20261025/sources/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/VERIFY.json": "4543e838e81dff7cceb7f539a94eedbd891ed5330518e55e997ba93ec4f51356", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/verify.py": "24074e4e954cf455b207ff346c7d983d51c06e1fa967747bc98e8f24f5bd1f80", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/PROOF.md": "1961e8b8be133cee19ec2523f6ba40da02905444a8c9601e97f66627b1129b32", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/WORD.json.gz": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/TASK.json": "ae1aff13f641c94a977599c1946dd0ff678daae51aad83662aa7056626e0dee6", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/RESULT.json": "b1dc682a4d9db5a726fbdf5c05c081f3c9ff9816829e5d8c900db1904a1f98c1", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/SOURCES.json": "42a7f956bf450c15a92449e285bd2b355159cc99e78bc1d815a4b902221ab89f", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/README.md": "19fec538e0eae59eeef90099ab220bef820467272410533fc95ee6236f44c4cd", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/construct.py": "b95eeb2c21c9e2d97d9a441483aa398e38eba65ecec57241bce77cd1234682d0", + "capsule/outputs/p104-contact-reassessment-20261025/sources/contact/pricing.py": "f74461d08c1cfdb9d500ac4f0da11f1b2d66a149bb342145b9aab9df703017a9", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/caller.py": "300d40043953e4f6aecfde8f2d1004b8ad6dc5a79ec3c7666c9908c2466c91c8", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/WORD.json.gz": "e5e955d7c9d5ea5dfea49c0e093037df577aa43813dcad5427ebca41a4ad35ec", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/CONTROLLER.json": "a84f6bbd547379597464e56c420cc665f96bc43a9a1351eed4b7cd0fce3cc4b9", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/price.py": "e46c1264c4acb037bae4df36ccdf3386980ef3d178aa7f0607dbd3f3333ed139", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/PROOF.md": "f4c4e400092954562252df6c4dd157a9b4c1642252168ce72738cdbecfc5ad41", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/RESULT.json": "03e9f8424b9166899d3ae3b188d9defb851162a3183ecab237fb783d78216782", + "capsule/outputs/p104-contact-reassessment-20261025/sources/predecessor/local.py": "878734dfd64c4b9d362d0ae476cc5c2a19fe93e48b7378763b23f3e0dd0a5a71", + "capsule/swarm-price-plane-20261023T112711Z/coordination/run_guarded.py": "720153b7491acede2c66bdc2dfd3174653195fa3222ec3589d0671c406a5bad8" + } +} diff --git a/research/p104-joint-contact/native-peer/inputs/PR5548-NATIVE-PROOF.md b/research/p104-joint-contact/native-peer/inputs/PR5548-NATIVE-PROOF.md new file mode 100644 index 0000000000..d968f3c93a --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/PR5548-NATIVE-PROOF.md @@ -0,0 +1,67 @@ +# Conditional native replacement lemma for the PR5545 contact + +This lemma states the implication checked in this bounded audit. Its finite +matrix premises are recorded by the scientific receipt; no success is inferred +merely from writing this document. It retains the source's ideal native chart +and prescribed digit-column implementation conventions. + +Let H be the nine-axis512-dimensional complex field space. For source frames +A739,B240,D127, let Φ_A,Φ_B,Φ_D be the pinned source chart operators and put +T_VU=Φ_V Φ_U^{-1}. Let U_BA,U_DB,U_DA be the exact emitted native recipes. +The finite premises to check are U_VU=T_VU, including absolute phase, and the +charged ranks1,5,6. Each recipe includes its explicit two ordinary monomial +boundaries around the positive rank-r Gaussian child. + +At source event16798, register341 holds arbitrary x_B and register345 holds +arbitrary y_A. The old fragment ends with + +``` +341 = -U_DB x_B + U_DB U_BA y_A +345 = U_DB U_BA y_A. +``` + +The replacement ends with + +``` +341 = -U_DB x_B + U_DA y_A +345 = U_DA y_A. +``` + +The source chart identities imply U_DB U_BA=U_DA by cancellation of Φ_B^{-1}Φ_B. +The extra full-matrix composition test checks this using the actual lowered +recipes as well. The complete two-field block maps therefore agree on both +arbitrary inputs, including every phase. No clean-input assumption is used. + +The authenticated source-read windows contain no other read/write of either +register between its moved instructions. Other registers' interleaved events +commute with this replacement because they touch neither operand. Prefix and +suffix events, ordinary scalar coefficients/order and owned INIT/COPY/CLEAR +are unchanged. The complete supplier thus has the same physical endpoint +whenever the other retained native instructions satisfy their source contract. + +For every positive digit-column count f, use Φ_V,f=Φ_V^{⊗f} and U_VU,f=U_VU^{⊗f} +as prescribed by the source. Since (AB)^{⊗f}=A^{⊗f}B^{⊗f}, the same composition +identity holds at every f. Common linear U commutes with the role-level scalar +ADD/SCALE. The exterior coefficient−1 stays−1; it is not raised to f. Native +operator phases are inside their unary tensor maps and are raised correctly. +Any untouched spectator factor is an identity tensor factor. This is an +algebraic implication, not extrapolation from a few tested widths. + +All original entry/exit charts, helper targets and owned lifetimes are fixed. +The caller's18 source-word invocations remain forward. For any retained caller +boundary maps E_in/E_out, replacing an equal supplier operator preserves +E_out W E_in. This validates transfer of this contact conditional on the parent +caller; it does not prove those265-axis maps themselves implement the desired +global Gaussian. Their independent physical audit remains a later layer. + +The recursive bill changes from H1+2H5 to H5+H6 per invocation. Ordinary +monomial factors remain explicit; they are not free Gaussian calls. The +previously checked complete delta −18H1−18H5+18H6 and zero target delta retain +their narrower invoice evidence. No new funding or κ is supplied by this lemma. + +Credit Ali Romman for PR5544/5545 and its source contact; the retained +Clifford/native compiler and independent Gaussian-review authors; Gareth +Davidson, David Arias, Cinna Davis, Jacob Alan Sussman, zxv, Cao Yifan and the +shared-chart/dual-ADD predecessors. New focused matrix audit and explicit +replacement implication for Chris R/Clear1nsight with OpenAI Codex assistance. +Apache-2.0. No independent human or formal-kernel acceptance is claimed. diff --git a/research/p104-joint-contact/native-peer/inputs/PR5548.json b/research/p104-joint-contact/native-peer/inputs/PR5548.json new file mode 100644 index 0000000000..34a899cc81 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/PR5548.json @@ -0,0 +1,9 @@ +{ + "body": "## Change and mathematical scope\n\nAdds one source-pinned, reproducible supporting audit of [PR #5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545), plus a ceiling on repeating only its `H1+H5\u2192H6` edit. **No new construction, \u03ba gain, selected update or complete parent admission is claimed.**\n\nThe contact moves the subtraction/sign on registers 341/345 to a full common chart. A separately written interpreter checks all 743 normalized endpoint rows, owned returns, source-read windows and complete before/after invoices. The exact paid delta is `-18H1-18H5+18H6`, with every productive target retained.\n\nA new dense Gaussian-dyadic interpreter verifies every column of the three actual lowered rank-1/5/6 transports and their old-route/direct-route composition: **1,048,576 complex entries per mode**, including absolute phase. It uses neither vendor state interpreter for matrix comparison. The pinned source compiler and credited literal chart/recipe descriptions are reused. [NATIVE-PROOF.md](https://github.com/Clear1nsight/integer-mult-bounds/blob/b038f9d9b5cf0ce92184da909e57a3be476fc812/research/p104-contact-independent-audit/NATIVE-PROOF.md) states the conditional positive-width tensor/substitution implication, with exterior scalar coefficients kept outside tensor powers.\n\nEven granting all 1,926 remaining global H5 jobs legal independent replacements without added cost, the frozen-target edit family has raw ceiling **(.003106074473, .003106074474)** and cannot fund .0033. [CEILING.md](https://github.com/Clear1nsight/integer-mult-bounds/blob/b038f9d9b5cf0ce92184da909e57a3be476fc812/research/p104-contact-independent-audit/CEILING.md) gives the full model, monotonicity proof and broader rank-mass relaxation. This is not a ceiling on P104 or different paid-path changes.\n\nThe parent's other native maps, 265-axis routes, archived source generator, full precision/tape and compiler/58-outer-predicate conjunction were not independently replayed. Five framework assumptions remain; no independent human or proof-kernel acceptance is claimed.\n\n## Task and overlap\n\nCanonical base and direct publication parent: `32890bc5de034ab8fc93ac88ead7279a6a416d04`. Reviewed PR #5545 head: `18968423711fd902aaee1099979497d55603e1dc`; predecessor PR #5544: `e2a6cce2f9db5a2c5f9714f4b9e5292dd3a10581`. Publication: `b038f9d9b5cf0ce92184da909e57a3be476fc812`.\n\nTask `scalar-to-moment`, priority revision 7, **changed scope / partial**: explicit user-assigned verification and edit-family ceiling, rather than the original positive construction-gain gate. That gate is not claimed met. The author [released scope and requested independent review](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19169220). This publishes the checker behind our [previously local-only focused handoff](https://github.com/CrocSwap/integer-mult-bounds/pull/5545#issuecomment-6396679760) and adds native full-column validation.\n\nPR #5544/#5545 retain authorship of the construction and complete claimed endpoint. Existing shared-chart/dual-ADD packages supply the general retiming method. Our #5546 concerns a different fixed-cut helper obstruction and is not consumed. Live PR/discussion checks found no newer overlapping successor in the bounded visible coverage; hidden/unpublished coverage is incomplete, so no exclusivity claim.\n\nThe byte-preserved capsule retains source data/context, exact checkers and outputs for authentication. Frozen author code is retained with its notices; it is not claimed as new work. Runtime executes only the new audit scripts, the credited prior interval engine and pinned canonical Clifford compiler/circuit definitions. No pending Git object, network, author-side price/native evaluator or workstation path is needed.\n\n## Validation\n\nPython 3.12.3, standard library:\n\n```sh\npython3 -B scripts/research_package.py --package research/p104-contact-independent-audit --check-only\npython3 -B scripts/research_package.py --package research/p104-contact-independent-audit\npython3 -B scripts/check_research_commit.py --package research/p104-contact-independent-audit --check-source-history\n```\n\nExpected scientific marker: `PASS_P104_CONTACT_INDEPENDENT_AUDIT`.\n\n- Metadata and canonical pins passed. Exact published-commit byte/source-history preflight passed for 42 files. Remote tree equals the locally checked tree; canonical main is its direct parent.\n- Registered normal/optimized replay passed under the unchanged shared guard in **19.017 s / 94.82 MiB** sampled peak, within 150 s / 512 MiB. Every scientific byte matches both frozen original outputs; zero exclusions.\n- A relocated read-only Git-free export with spaces in its path and empty PATH passed optimized replay in **9.468 s / 69.41 MiB**. All 42 exported files stayed unchanged.\n- Native controls reject three phase-only errors invisible to signed Pauli tableaux, inverse children, wrong monomial boundaries and wrong declared ranks, plus two source-authentication faults. Contact controls reject one-sided retiming, wrong sign and an intervening source read.\n- Separate on-disk canonical-source and expected-receipt corruption controls fail before scientific subprocesses. The injected source exception was never imported.\n- The independent dense matrix engine is new; the interval engine and native compiler/definitions are credited reused code. Mode equality is reproducibility, not a second independent implementation. Hosted CI remains separate from these local checks.\n\nThe saved raw crossing is independently bracketed and the integer compiler grid is checked; this is not a fresh full parent funding proof. [REVIEW.md](https://github.com/Clear1nsight/integer-mult-bounds/blob/b038f9d9b5cf0ce92184da909e57a3be476fc812/research/p104-contact-independent-audit/REVIEW.md) records boundaries and original versus portable receipts.\n\n## Credit\n\nAli Romman (#5544/#5545); Gareth Davidson (#2305); David Arias (#2152); Cinna Davis (#2219/controller); Jacob Alan Sussman (productive recursion); zxv/compiler, Cao Yifan, retained Clifford/native-review, shared-chart, dual-ADD, geometry, COPY and analytic contributors. Frozen source notices are preserved.\n\nNew focused checkers, scoped ceiling, replacement implication and publication prepared for Chris R/Clear1nsight with substantial OpenAI Codex assistance. New material Apache-2.0. No independent human or formal-kernel acceptance is claimed.\n\n## Open next questions\n\nSee [TASK.json](https://github.com/Clear1nsight/integer-mult-bounds/blob/b038f9d9b5cf0ce92184da909e57a3be476fc812/research/p104-contact-independent-audit/TASK.json) and the seven-field [HANDOFF.md](https://github.com/Clear1nsight/integer-mult-bounds/blob/b038f9d9b5cf0ce92184da909e57a3be476fc812/research/p104-contact-independent-audit/HANDOFF.md).\n\n1. Independently validate one missing 265-axis physical caller/funding layer with explicit source/cost coverage; full parent admission remains the blocker.\n2. Nominate one broader chronological paid-path change with complete optimistic costs and one small falsifier. The broad regrouping relaxation is not a physical witness, and repeated H5 edits cannot reach .0033. Check live claims first.\n\nThe completed audit has stopped. This submission starts no further search and authorizes no merge or selected change.\n", + "head_repo": "Clear1nsight/integer-mult-bounds", + "head_sha": "b038f9d9b5cf0ce92184da909e57a3be476fc812", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5548", + "number": 5548, + "title": "Independently verify P104 contact phases and bound repeated H5 retiming (no new \u03ba)", + "updated_at": "2026-10-25T11:14:59Z" +} diff --git a/research/p104-joint-contact/native-peer/inputs/PR5550.json b/research/p104-joint-contact/native-peer/inputs/PR5550.json new file mode 100644 index 0000000000..cec8a0b5ac --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/PR5550.json @@ -0,0 +1,9 @@ +{ + "body": "## Change and mathematical scope\n\nPublishes an independent, source-bound audit of the **265-axis forward P104 caller and its productive target bindings** in [PR #5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545). This closes one finite validation layer under retained premises. **No new construction, paid-profile change, \u03ba gain, global ceiling or full parent admission is claimed.**\n\nThe checker covers 7,488 actual entry/exit contacts and their composed local block coefficients, the complete 32-bank free-Laurent caller, 3,328 main input/output canonicalizers and final corrections, 527 native helper normalizers, 208 intrinsic main adapters, and 9,486 fresh helper identities. It emits all 3,120 whole-idle jobs and 1,560 corrected positive-child query recipes. The complete invoice is unchanged: **69,912 paid jobs and 12,814 independent productive fields**.\n\nThe [proof/accounting argument](https://github.com/Clear1nsight/integer-mult-bounds/blob/6125c07ae8ba4b8550e2a0a28a2c6be503153059/research/p104-caller-independent-audit/PROOF.md) binds actual route phases and target input aliases. It keeps scalar signs outside digit-column tensor powers and excludes scratch and spectators from productive credit. Signed-Pauli equality plus an independently executed exact dense phase anchor checks the native target maps. Source compiler and literal circuit definitions are credited reuse.\n\nThe separate 127,292,680 ordinary figure is an **abstract address/phase/scalar pass bound under retained per-pass/tape costs**, below the source allowance 184,647,552. It is not newly funded machine work, a precision theorem, recursive rank credit or a \u03ba reserve.\n\nThe all-input/all-width local native ABI and untouched paid-map correctness remain inherited. Owned query cleanup is checked against the fixed template; the erasure framework is not independently proved. Contact inverses are not a complete-caller raw inverse transpose. Full raw dual, uniform precision/tape/storage, compiler reserve, complete outer conjunction and human/formal acceptance remain open. Five framework assumptions remain. See [review limits](https://github.com/Clear1nsight/integer-mult-bounds/blob/6125c07ae8ba4b8550e2a0a28a2c6be503153059/research/p104-caller-independent-audit/REVIEW.md).\n\n## Task and overlap\n\nTask `scalar-to-moment`, priority revision 7, **changed scope / partial**, from the explicit user assignment to validate this pending caller. The card's positive paid-profile gain gate is not claimed met. [TASK.json](https://github.com/Clear1nsight/integer-mult-bounds/blob/6125c07ae8ba4b8550e2a0a28a2c6be503153059/research/p104-caller-independent-audit/TASK.json) preserves the original card and states the actual scope.\n\nPublication: `6125c07ae8ba4b8550e2a0a28a2c6be503153059`, directly based on canonical `32890bc5de034ab8fc93ac88ead7279a6a416d04`. Reviewed PR #5545: `18968423711fd902aaee1099979497d55603e1dc`; predecessor #5544: `e2a6cce2f9db5a2c5f9714f4b9e5292dd3a10581`. The source author [released scope and requested independent review](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19169220). Current main guidance, relevant source/PR discussion and bounded changed-PR checks were refreshed. No competing successor appeared in that coverage; hidden/unpublished work is not covered exhaustively.\n\nOur [PR #5548](https://github.com/CrocSwap/integer-mult-bounds/pull/5548), head `b038f9d9b5cf0ce92184da909e57a3be476fc812`, covers the earlier local contact/native replacement and scoped repeated-H5 ceiling. This PR adds the forward caller/target layer. It reuses only the dense interpreter needed here and authenticates previous receipts without rerunning those older audits. The predecessor construction and packages are unchanged.\n\nThe source-bound capsule retains the exact successful checker, complete expected output and authenticated inputs. Pending source bytes are included for offline replay; no pending Git object or network is required at runtime. Canonical compiler, circuit and phase sources remain declared live inputs. Source-history checks authenticate those registered pins, not merger or acceptance of the pending construction.\n\n## Validation\n\nPython 3.12.3, standard library:\n\n```sh\npython3 -B scripts/research_package.py --package research/p104-caller-independent-audit --check-only\npython3 -B scripts/research_package.py --package research/p104-caller-independent-audit\npython3 -B scripts/check_research_commit.py --package research/p104-caller-independent-audit --check-source-history\n```\n\nExpected marker: `PASS_P104_FORWARD_CALLER_INDEPENDENT_AUDIT`.\n\n- Metadata/pins and exact published-commit/source-history checks passed for all **38 package/input files**. Remote tree equals the checked local tree; canonical main is the direct parent.\n- Original normal/optimized pair passed under the unchanged shared guard in **100.917 s / 82.35 MiB**, within 150 s / 512 MiB. Every **5,990,419 scientific output bytes** matches, zero scientific exclusions. SHA256: `b51a7d19c10faea7d569a48e9536db8ba1e7418f8dd8dfb25646cc87cc9c4009`.\n- The registered portable normal/optimized replay passed in **103.299 s / 123.77 MiB** under the same outer cap, comparing every byte with the frozen original output.\n- A relocated read-only, Git-free optimized export with spaces in its path and empty PATH passed in **47.173 s / 90.91 MiB**. All **39 exported files** remained unchanged.\n- Ten scoped controls reject wrong route, omitted contact translation, nonzero absolute phase, exterior sign error, lost idle, helper alias collision, missing final translation, scratch/source collision, missing inverse-Q correction and packed-exponent overflow. Negative-power cancellation also passes. Control scope is explicit; not every control is a full mutated-source replay.\n- Separate on-disk canonical-source and expected-receipt corruptions fail before the scientific worker. An injected source exception was not imported. A fresh private bytecode namespace also isolates the scientific subprocess.\n\nThe first checker exceeded 512 MiB before a result; its frozen code and closeout are retained as history. The successful revision bounds the phase cache, packs all 34 exact exponents with overflow rejection, and streams output. It retains all 265 axes and full matrix coverage; no floating or finite-order shortcut is used. Original operational stage traces are separate from scientific output. Mode equality is reproducibility, not independent human review. Hosted CI for this PR is separate from these completed local receipts and from #5548's hosted success.\n\n## Credit\n\nAli Romman (#5544/#5545); Gareth Davidson (#2305), David Arias (#2152), Cinna Davis (#2219/controller); Jacob Alan Sussman, zxv, Cao Yifan and retained native, Clifford, geometry, tensor, compiler and analytic authors. Original source notices remain intact.\n\nNew independent checker, memory-bounded representation, source custody and publication for Chris R/Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. No independent human or proof-kernel acceptance claimed.\n\n## Open next questions\n\nThe [structured questions](https://github.com/Clear1nsight/integer-mult-bounds/blob/6125c07ae8ba4b8550e2a0a28a2c6be503153059/research/p104-caller-independent-audit/TASK.json) and [seven-field handoff](https://github.com/Clear1nsight/integer-mult-bounds/blob/6125c07ae8ba4b8550e2a0a28a2c6be503153059/research/p104-caller-independent-audit/HANDOFF.md) specify relevance, first steps and blockers.\n\n1. Review target input aliases and the ordinary-cost premises, then choose one missing native/complete-caller-dual obligation. The actual raw inverse transpose and untouched paid native foundation matter before invoking parent funding.\n2. Bind precision/tape/storage, erasure and retained compiler/outer reserves to this fixed complete caller. The abstract pass census is not that conjunction.\n3. For \u03ba\u2265.0033, nominate one broader paid-path mechanism with complete optimistic costs and a small physical falsifier. This unchanged invoice does not lift #5548's repeated-H5 raw ceiling (.003106074473,.003106074474).\n\nThis completed layer stops after publication. No new construction scan, recurring worker, merge or selected change is authorized by the submission.\n", + "head_repo": "Clear1nsight/integer-mult-bounds", + "head_sha": "6125c07ae8ba4b8550e2a0a28a2c6be503153059", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5550", + "number": 5550, + "title": "Independently verify the P104 forward caller and target bindings (no new \u03ba)", + "updated_at": "2026-10-25T12:28:05Z" +} diff --git a/research/p104-joint-contact/native-peer/inputs/PUBLIC-WORD.json.gz b/research/p104-joint-contact/native-peer/inputs/PUBLIC-WORD.json.gz new file mode 100644 index 0000000000..c04a815c26 Binary files /dev/null and b/research/p104-joint-contact/native-peer/inputs/PUBLIC-WORD.json.gz differ diff --git a/research/p104-joint-contact/native-peer/inputs/SOURCE-WORD.json.gz b/research/p104-joint-contact/native-peer/inputs/SOURCE-WORD.json.gz new file mode 100644 index 0000000000..1ce96b0130 Binary files /dev/null and b/research/p104-joint-contact/native-peer/inputs/SOURCE-WORD.json.gz differ diff --git a/research/p104-joint-contact/native-peer/inputs/clifford_exact.py b/research/p104-joint-contact/native-peer/inputs/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> j) & 1) << i for i, row in enumerate(matrix)) for j in range(len(matrix))) + + +def inverse(matrix): + n = len(matrix) + rows = [row | (1 << (n+i)) for i, row in enumerate(matrix)] + for j in range(n): + pivot = next((i for i in range(j, n) if rows[i] >> j & 1), None) + require(pivot is not None, 'singular binary chart') + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(n): + if i != j and rows[i] >> j & 1: + rows[i] ^= rows[j] + require([row & ((1 << n)-1) for row in rows] == [1 << i for i in range(n)], 'binary inverse') + return tuple(row >> n for row in rows) + + +def extend(vectors, n): + columns, pivots = [], {} + for value in tuple(vectors) + tuple(1 << i for i in range(n)): + reduced = value + while reduced: + j = reduced.bit_length()-1 + if j not in pivots: + pivots[j] = reduced + columns.append(value) + break + reduced ^= pivots[j] + require(len(columns) == n, 'frame basis extension') + return tuple(columns) + + +def adjoint(circuit): + out = [] + for gate in reversed(circuit): + if gate[0] == 'P': + out.append(('P', inverse(gate[1]))) + elif gate[0] == 'D': + out.append(('D', gate[1], tuple(-a % 4 for a in gate[2]))) + elif gate[0] == 'C': + out.append(('C', gate[1], -gate[2])) + elif gate[0] == 'phase': + out.append(('phase', -gate[1] % 4)) + else: + require(gate[0] == 'X', 'adjoint gate type') + out.append(gate) + return tuple(out) + + +def fourier(rank): + return tuple(('C', 1 << i, 1) for i in range(rank)) + + +def frame(vectors, n): + rank = len(vectors) + if rank == 0: + return () + if rank == n: + return fourier(n) + matrix = transpose(extend(vectors, n)) + columns = transpose(inverse(matrix)) + quadratic = tuple((1 << i) ^ sum(parity(a & b) << j for j, b in enumerate(columns)) for i, a in enumerate(columns)) + diagonal = tuple((row >> i) & 1 for i, row in enumerate(quadratic)) + chart = (('P', matrix), ('D', quadratic, diagonal)) + return adjoint(chart) + fourier(rank) + chart + + +def monomial(record): + matrix = tuple(record['matrix_rows']) + quadratic = tuple(record['quadratic_rows']) + linear = tuple(record['linear_Z4']) + require(transpose(quadratic) == quadratic, 'quadratic symmetry') + require(len(matrix) == len(quadratic) == len(linear) == 9, 'monomial dimension') + require(all(a % 2 == (quadratic[i] >> i) & 1 for i, a in enumerate(linear)), 'diagonal parity') + inverse(matrix) + return (('D', quadratic, linear), ('P', matrix), ('X', record['offset']), ('phase', record['phase'])) + + +def recipe(record): + rank = record['rank'] + require(isinstance(rank, int) and 0 <= rank <= 9, 'child rank') + if rank == 0: + require(record['right'] is None, 'rank zero right factor') + return monomial(record['left']) + return monomial(record['right']) + fourier(rank) + monomial(record['left']) + + +def tableau(circuit, n=9): + rows = [(1 << i, 0, 0) for i in range(n)] + [(0, 1 << i, 0) for i in range(n)] + for gate in circuit: + tag = gate[0] + out = [] + inverse_transpose = transpose(inverse(gate[1])) if tag == 'P' else None + for x, z, phase in rows: + if tag == 'P': + x, z = mul(gate[1], x), mul(inverse_transpose, z) + elif tag == 'X': + phase += 2 * parity(z & gate[1]) + elif tag == 'C': + if parity(z & gate[1]): + x ^= gate[1] + phase += 3 * gate[2] + elif tag == 'D': + quadratic, linear = gate[1:] + phase += sum(linear[i] for i in range(n) if x >> i & 1) + phase += 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(n) if x >> i & 1) + z ^= mul(quadratic, x) + else: + require(tag == 'phase', 'tableau gate type') + out.append((x, z, phase % 4)) + rows = out + return tuple(rows) + + +@lru_cache(maxsize=512) +def action(gate): + if gate[0] == 'P': + return tuple(mul(gate[1], x) for x in range(512)) + require(gate[0] == 'D', 'state action type') + quadratic, linear = gate[1:] + return tuple((sum(linear[i] for i in range(9) if x >> i & 1) + + 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(9) if x >> i & 1)) % 4 for x in range(512)) + + +def rotate(pair, power): + a, b = pair + return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4] + + +def state(circuit, basis=0): + value, denominator = {basis: (1, 0)}, 0 + for gate in circuit: + tag = gate[0] + result = {} + if tag == "C": + direction, sign = gate[1:] + for address, (a, b) in value.items(): + for target, pair in ((address, (a - sign*b, b + sign*a)), + (address ^ direction, (a + sign*b, b - sign*a))): + old = result.get(target, (0, 0)) + result[target] = (old[0] + pair[0], old[1] + pair[1]) + denominator += 1 + else: + for address, pair in value.items(): + if tag == "P": + target = mul(gate[1], address) + elif tag == "X": + target = address ^ gate[1] + else: + target = address + if tag == "D": + pair = rotate(pair, action(gate)[address]) + else: + require(tag == "phase", "Unknown Gaussian state gate") + pair = rotate(pair, gate[1]) + require(target not in result, "A monomial address map is not injective") + result[target] = pair + value = {address: pair for address, pair in result.items() if pair != (0, 0)} + while denominator and all((a | b) % 2 == 0 for a, b in value.values()): + denominator -= 1 + value = {address: (a//2, b//2) for address, (a, b) in value.items()} + return value, denominator + + +def equal(actual, expected, label): + require(tableau(actual) == tableau(expected), label + ": signed Pauli action") + require(state(actual) == state(expected), label + ": exact global phase") + + +def verify(data, certificate): + word = data["word"] + original, clean = data["programs"], data["clean_programs"] + source_recipes = data["recipes"] + residuals = data["residuals"]["recipes"] + native_tags = {"climb", "adapter", "residual_adapter"} + for orientation in ("forward", "backward"): + native = [event for event in clean[orientation] if event[0] in native_tags] + require(native == [event for event in original[orientation] if event[0] in native_tags], + "A retained native event changed") + require(len(native) == 5056, "The retained native event count changed") + frames = [frame(tuple(vectors), 9) for vectors in word["frames"]] + used = {(event[3], event[4]) for program in clean.values() + for event in program if event[0] == "climb"} + children = {(record["old"], record["new"]): record for record in source_recipes["children"]} + require(len(children) == len(source_recipes["children"]) and used <= set(children), + "The retained child recipe coverage is incomplete") + for old, new in sorted(used): + record = children[old, new] + require(record["rank"] == len(word["frames"][new]) - len(word["frames"][old]), + "A retained child has the wrong rank") + equal(recipe(record), adjoint(frames[old]) + frames[new], "Retained child") + endpoints = {(record["role"], record["port"]): record + for record in source_recipes["endpoint_adapters"]} + require(len(endpoints) == len(source_recipes["endpoint_adapters"]) + and set(endpoints) == {(role, p) for role in ("source", "target") for p in range(112)}, + "The endpoint adapter coverage is incomplete") + for (role, port), record in endpoints.items(): + direction = word["ports"][port] + conventional = (("C", direction, 1),) if role == "source" else ( + ("C", direction, -1),) + fourier(9) + index = word["start"][port] if role == "source" else word["final"][112 + port] + require(record["frame"] == index and record["rank"] == 0, "An endpoint frame changed") + equal(recipe(record), adjoint(conventional) + frames[index], "Endpoint adapter") + used_residuals = set() + for program in clean.values(): + for event in program: + if event[0] != "residual_adapter": + continue + _, position, register, entry, *tail = event + terminal = tail[0] if tail else 1 + key = str(entry) if terminal == 1 else str(entry) + ":" + str(terminal) + require(key in residuals and position in ("pre", "post"), "A residual binding changed") + require(entry == word["start"][register] and terminal == word["final"][register], + "A residual endpoint changed") + used_residuals.add(key) + for key in sorted(used_residuals): + record = residuals[key] + equal(recipe(record), adjoint(frames[record["frame"]]) + frames[record.get("terminal", 1)], + "Residual adapter") + records = certificate["input_recipes"] + ports = certificate["compensation_ports"] + require([record["port"] for record in records] == ports and len(records) == 8, + "The eight input recipes changed") + columns = 0 + for item in records: + port, label = item["port"], item["label"] + require(label == word["ports"][port] and item["canonical_start_frame_id"] == word["start"][port], + "An input recipe has the wrong supplier label") + record = item["recipe"] + require(record["rank"] == 1, "An input copy has the wrong child rank") + for side in ("left", "right"): + factor = record[side] + require(factor["quadratic_rows"] == [0] * 9 and factor["linear_Z4"] == [0] * 9 + and factor["offset"] == factor["phase"] == 0, + "An input factor is not an address permutation") + actual, expected = recipe(record), (("C", label, 1),) + equal(actual, expected, "Positive inherited input line") + for basis in range(512): + require(state(actual, basis) == state(expected, basis), "A complete input Gaussian column differs") + columns += 1 + negative = monomial(record["right"]) + (("C", 1, -1),) + monomial(record["left"]) + require(tableau(negative) != tableau(expected) or state(negative) != state(expected), + "An inverse input child was not detected") + phased = actual + (("phase", 1),) + require(tableau(phased) == tableau(actual) and state(phased) != state(expected), + "An input phase-only error was not detected") + return {"status": "PASS_EXACT_INPUT_NATIVE_FRAMES", "retained_native_events_per_orientation": 5056, + "retained_child_recipes": len(used), "endpoint_adapter_recipes": len(endpoints), + "residual_adapter_recipes": len(used_residuals), "new_input_recipes": len(records), + "new_exact_gaussian_columns": columns, "inverse_input_child_controls": len(records), + "phase_only_controls": len(records), "address_permutation_factors": 2 * len(records), + "method": "Independent signed Pauli and exact Gaussian interpretation; no compiler import", + "scope": "Positive inherited input frames before every retained adapter. No recursive hosting claim."} diff --git a/research/p104-joint-contact/native-peer/inputs/pr5548_dense_check.py b/research/p104-joint-contact/native-peer/inputs/pr5548_dense_check.py new file mode 100644 index 0000000000..e7e663beba --- /dev/null +++ b/research/p104-joint-contact/native-peer/inputs/pr5548_dense_check.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +"""Exact native-contact matrices; no floating arithmetic or vendor state engine. + +Source compiler and literal circuit descriptions retain their original credit. +New dense Gaussian-dyadic execution and audit: Codex-assisted, Apache-2.0. +""" +from pathlib import Path +from collections import Counter +from functools import lru_cache +from copy import deepcopy +import gzip +import hashlib +import importlib.util +import json +import sys + +B=Path(__file__).resolve().parent +ROOT=B.parents[1] +PRIOR=ROOT/'outputs/p104-contact-reassessment-20261025' +N=512 + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def authenticate(raw, expected): + need(sha(raw)==expected,'source authentication before import') + + +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 frozen(value): + return tuple(frozen(x) for x in value) if isinstance(value,(tuple,list)) else value + + +@lru_cache(None) +def prepared(gate): + tag=gate[0] + if tag=='P': + rows=gate[1] + need(len(rows)==9 and all(type(r) is int and 0<=r>j)&1)==((q[j]>>i)&1) for i in range(9) for j in range(9)), + 'symmetric quadratic form') + need(all((linear[i]&1)==((q[i]>>i)&1) for i in range(9)), 'quadratic diagonal parity') + phases=[] + for x in range(N): + degree_one=sum(linear[i] for i in range(9) if x>>i&1) + cross=0 + for i in range(9): + if x>>i&1: + for j in range(i+1,9): + if x>>j&1 and q[i]>>j&1: + cross+=2 + phases.append((degree_one+cross)%4) + return tag,tuple(phases) + if tag=='C': + direction,sign=gate[1:] + need(type(direction) is int and 0>remove for v in real];imag=[v>>remove for v in imag] + denominator-=remove + return real,imag,denominator + + +def compare_all(actual, expected, label): + a,b=compile_circuit(actual),compile_circuit(expected) + digest=hashlib.sha256() + for column in range(N): + left=dense_column(a,column) + right=dense_column(b,column) + need(left==right,label+' exact complete matrix column '+str(column)) + re,im,d=left + need(sum(v*v for v in re)+sum(v*v for v in im)==1<<(2*d),label+' exact column norm') + digest.update(json.dumps([column,d,re,im],separators=(',',':')).encode()) + digest.update(b'\n') + return {'columns':N,'complex_entries':N*N,'matrix_sha256':digest.hexdigest()} + + +def first_difference(actual,expected): + a,b=compile_circuit(actual),compile_circuit(expected) + for column in range(N): + if dense_column(a,column)!=dense_column(b,column): + return column + raise ValueError('deliberate native fault was accepted') + + +def main(): + manifest=json.loads((B/'INPUTS.json').read_text()) + for name,expected in manifest['files'].items(): + authenticate((ROOT/name).read_bytes(),expected) + # Transitive source closure and previous normalized/invoice evidence stay + # frozen. Authentication is not a rerun of their scientific computation. + oldpins=json.loads((PRIOR/'INPUTS.json').read_text()) + for name,expected in oldpins['files'].items(): + authenticate((ROOT/name).read_bytes(),expected) + oldreceipt=json.loads((PRIOR/'PAIR-RECEIPT.json').read_text()) + authenticate((PRIOR/'RESULT-normal.json').read_bytes(),oldreceipt['result_sha256']) + oldresult=json.loads((PRIOR/'RESULT-normal.json').read_text()) + need(oldresult['reviewed_head']==manifest['reviewed_head'] and + oldresult['source_endpoint']==oldresult['changed_endpoint']=='pass', + 'exact preceding source-bound endpoint coverage') + sourcepins=json.loads((PRIOR/'sources/contact/SOURCES.json').read_text())['files'] + for name in ('clifford_exact.py','native_verify.py'): + pin=next(p for p in sourcepins if p['path']=='research/p104-native-channel/vendor/'+name) + raw=(B/'sources'/name).read_bytes() + authenticate(raw,pin['sha256']) + try:authenticate(raw+b'\n',pin['sha256']) + except ValueError:pass + else:raise ValueError('source corruption control accepted') + C=load(B/'sources/clifford_exact.py','p104_native_audit_compiler') + V=load(B/'sources/native_verify.py','p104_native_literal_definitions') + old=json.loads(gzip.decompress((PRIOR/'sources/predecessor/WORD.json.gz').read_bytes())) + new=json.loads(gzip.decompress((PRIOR/'sources/contact/WORD.json.gz').read_bytes())) + need({k:v for k,v in old.items() if k!='program'}=={k:v for k,v in new.items() if k!='program'}, + 'public contract, charts, endpoints and ports unchanged') + edits={16798:[['MOVE',341,240,127,False],['MOVE',345,739,127,False]], + 16799:[['ADD',341,345,'-1',127]],16800:[['SCALE',341,'-1',127]],17061:[],17067:[]} + need(new['program']==[e for i,old_event in enumerate(old['program']) for e in edits.get(i,[old_event])], + 'only the five source sites change') + need([e[:-1] for e in old['program'] if e[0]!='MOVE']== + [e[:-1] for e in new['program'] if e[0]!='MOVE'],'owned and scalar schedule unchanged') + before=Counter((e[2],e[3]) for e in old['program'] if e[0]=='MOVE') + after=Counter((e[2],e[3]) for e in new['program'] if e[0]=='MOVE') + delta=Counter(after);delta.subtract(before) + need({k:v for k,v in delta.items() if v}=={(739,240):-1,(240,127):-1,(739,127):1}, + 'actual changed map multiplicities') + controller=json.loads((PRIOR/'sources/predecessor/CONTROLLER.json').read_text()) + full=[e for e in controller['physical_events'] if e[0]=='LOCAL'] + need(len(full)==18 and all(e[3] is False for e in full),'all18 full invocations use this forward word') + frames=old['frames'] + records={} + circuits={} + controls={} + for name,a,b,rank in [('AB',739,240,1),('BD',240,127,5),('AD',739,127,6)]: + need(len(frames[b])-len(frames[a])==rank,'literal native rank') + op=C.canonical_frame(9,tuple(frames[a])).adjoint().then(C.canonical_frame(9,tuple(frames[b]))) + recipe,_=C.lower_child(op) + need(recipe['rank']==rank and recipe['right'] is not None,'declared native child rank') + actual=V.recipe(recipe) + expected=V.adjoint(V.frame(frames[a],9))+V.frame(frames[b],9) + checked=compare_all(actual,expected,name) + records[name]={'old_frame':a,'new_frame':b,'rank':rank,'recipe':recipe, + 'actual_gate_count':len(actual),'expected_gate_count':len(expected),**checked} + circuits[name]=actual + phased=actual+(('phase',1),) + need(V.tableau(phased)==V.tableau(actual),'global phase fault invisible to signed Pauli tableau') + controls[name+'_global_phase']={'first_rejected_column':first_difference(phased,expected), + 'signed_tableau_unchanged':True} + inverse=list(actual) + at=next(i for i,g in enumerate(inverse) if g[0]=='C') + inverse[at]=('C',inverse[at][1],-inverse[at][2]) + controls[name+'_inverse_child']={'first_rejected_column':first_difference(tuple(inverse),expected)} + wrong=deepcopy(recipe);wrong['left']['offset']^=1 + controls[name+'_wrong_boundary']={'first_rejected_column':first_difference(V.recipe(wrong),expected)} + try:need(recipe['rank']+1==len(frames[b])-len(frames[a]),'wrong declared recursive rank') + except ValueError:controls[name+'_wrong_rank']='rejected' + else:raise ValueError('wrong rank accepted') + composition=compare_all(circuits['AB']+circuits['BD'],circuits['AD'],'old two-leg versus direct') + targets={str(r):{'initial_frame':old['initial'][r],'final_frame':old['final'][r], + 'rank':len(frames[old['final'][r]])-len(frames[old['initial'][r]])} + for r in (341,345)} + result={'schema':'p104-native-contact-exact-matrices/v1','reviewed_head':manifest['reviewed_head'], + 'source_hashes':manifest['files'],'maps':records,'old_route_equals_new':composition, + 'controls':controls,'source_authentication_controls':2, + 'direct_dense_complex_entries':3*N*N,'composition_complex_entries':N*N, + 'caller_binding':{'full_calls':18,'all_forward':True,'public_fields':735,'owned_lifetimes':8, + 'target_owners':targets,'public_chart_and_scalar_abi_unchanged':True, + 'previous_normalized_and_invoice_receipt_reused':oldreceipt['result_sha256'], + 'all_parent_native_maps_checked':False,'265_axis_routes_replayed':False}, + 'positive_width_implication':'exact one-column chart equality tensors factorwise; common transport commutes with scalar ADD/SCALE; exterior coefficients are not tensor-powered; spectators stay identity', + 'interpretation':'dense integer real/imaginary vectors with a common power-of-two denominator; no vendor state/tableau used for matrix equality', + 'new_kappa':None,'full_parent_funding_admitted':False,'stop':True} + print(json.dumps(result,sort_keys=True,separators=(',',':'))) + + +if __name__=='__main__':main() diff --git a/research/p104-joint-contact/native-peer/run.py b/research/p104-joint-contact/native-peer/run.py new file mode 100644 index 0000000000..70d3df583c --- /dev/null +++ b/research/p104-joint-contact/native-peer/run.py @@ -0,0 +1,100 @@ +"""Apply PR5548's credited independent dense interpreter to four new P104 maps. + +New inventory, bindings, rank-support checks and scoped controls: thu-nmrc +with substantial OpenAI Codex assistance. Apache-2.0. The reused arithmetic +engine is preserved byte-for-byte and retains Chris R/Clear1nsight's credit. +""" +from pathlib import Path +from collections import Counter,defaultdict +from hashlib import sha256 +from copy import deepcopy +import argparse,gzip,importlib.util,json,sys +sys.dont_write_bytecode=True +ROOT=Path(__file__).resolve().parent;IN=ROOT/'inputs' +def need(ok,why): + if not ok:raise ValueError(why) +def load(name,path): + s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);sys.modules[name]=m;s.loader.exec_module(m);return m +def enc(x):return json.loads(json.dumps(x,sort_keys=True)) +def read(n): + raw=(IN/n).read_bytes();return json.loads(gzip.decompress(raw)if n.endswith('.gz')else raw) +def authenticate(): + p=read('INPUT-PINS.json') + for n,h in p['files'].items():need(sha256((IN/n).read_bytes()).hexdigest()==h,'source authentication before import '+n) + need(p['files']['pr5548_dense_check.py']==p['PR5548_dense_module_sha256']=='43fd40847a0853c0ac511d58ce77ef822a5c6dd1b25f662f01cefaa3196a2f7d','exact credited dense module') + need(p['files']['PR5545-EXPORT.json']==p['PR5545_export_manifest_sha256'],'official source export manifest') + m=read('PR5545-EXPORT.json');need(m['commit']==p['reviewed_source_commit']and len(m['files'])==33,'official source head and full inventory') + rows={x['path']:x for x in m['files']} + for n,path in [('SOURCE-WORD.json.gz','research/p104-full-frame-contact/WORD.json.gz'),('clifford_exact.py','research/p104-native-channel/vendor/clifford_exact.py'),('native_verify.py','research/p104-native-channel/vendor/native_verify.py')]:need(rows[path]['sha256']==p['files'][n]and rows[path]['size']==(IN/n).stat().st_size,'retained source '+path) + inv=read('PR5548-CAPSULE-INVENTORY.json')['files'];need(inv['capsule/outputs/p104-native-contact-audit-20261025/check.py']==p['files']['pr5548_dense_check.py'],'published dense source inventory') + for n in ('clifford_exact.py','native_verify.py'):need(inv['capsule/outputs/p104-native-contact-audit-20261025/sources/'+n]==p['files'][n],'compiler/literal definitions shared with audited source') + return p + +def inventory(old,new): + need({k:v for k,v in old.items()if k!='program'}=={k:v for k,v in new.items()if k!='program'},'unchanged public/chart/target metadata') + need([e[:-1]for e in old['program']if e[0]!='MOVE']==[e[:-1]for e in new['program']if e[0]!='MOVE'],'exact scalar and owned schedule') + frames=old['frames'];data=[] + for w in (old,new): + d=defaultdict(list) + for i,e in enumerate(w['program']): + if e[0]=='MOVE':d[e[2],e[3]].append(dict(event=i,role=e[1],private=e[4])) + data.append(d) + before,after=data;added=set(after)-set(before);removed=set(before)-set(after);common=set(before)&set(after) + need(added=={(17,720),(17,782),(615,207),(775,207)},'exact four added maps') + def record(pair): + a,b=pair + return dict(source_frame=a,target_frame=b,source_basis=frames[a],target_basis=frames[b],rank=abs(len(frames[a])-len(frames[b])),before=before.get(pair,[]),after=after.get(pair,[]),multiplicity_delta=len(after.get(pair,[]))-len(before.get(pair,[]))) + changed=sorted(k for k in set(before)|set(after)if len(before.get(k,[]))!=len(after.get(k,[]))) + delta=Counter() + for k in changed:delta[record(k)['rank']]+=record(k)['multiplicity_delta'] + delta={r:n for r,n in sorted(delta.items())if n};need(delta=={1:2,2:-3,3:1,4:-1,5:1},'complete literal local paid delta') + return dict(before_distinct=len(before),after_distinct=len(after),common_distinct=len(common),added=[record(x)for x in sorted(added)],removed=[record(x)for x in sorted(removed)],all_changed_multiplicities=[record(x)for x in changed],local_paid_delta=delta,total_MOVE_count_before=sum(map(len,before.values())),total_MOVE_count_after=sum(map(len,after.values())),PR5548_paid_pairs=[[739,240],[240,127],[739,127]],PR5548_pair_overlap=[list(x)for x in sorted(added&{(739,240),(240,127),(739,127)})]) + +def compare(D,actual,expected,rank,label): + a,b=D.compile_circuit(actual),D.compile_circuit(expected);digest=sha256();supports=Counter();anchor=None + for column in range(512): + left=D.dense_column(a,column);right=D.dense_column(b,column) + need(left==right,label+' complete exact complex column '+str(column)) + re,im,d=left;need(sum(v*v for v in re)+sum(v*v for v in im)==1<<(2*d),label+' exact norm') + support=sum(bool(x or y)for x,y in zip(re,im));need(support==1<>t for k,v in row.items()};exp-=t + if exp<0:row={k:v<<(-exp) for k,v in row.items()};exp=0 + return row,exp +def audit(w): + spaces=[span(b) for b in w['frames']];dims=[len(b) for b in w['frames']] + n=len(w['initial'])+8;need(n==743 and w['public']==735,'input dimensions') + rows=[{r:1} for r in range(n)];exp=[0]*n;cur=w['initial'][:]+[None]*8 + owned=set();peak=0;lifetimes=0;paid=Counter();scalar_count=Counter();snapshots=[] + for i,e in enumerate(w['program']): + op,r=e[:2];need(0<=r=735 and r not in owned,'owned init');owned.add(r);peak=max(peak,len(owned));lifetimes+=1 + rows[r]={};exp[r]=0;cur[r]=e[2] + elif op=='CLEAR': + need(r in owned and cur[r]==e[2],'owned clear');owned.remove(r);rows[r]={};exp[r]=0;cur[r]=None + else: + q=Fraction(e[-2]);f=e[-1] + need(q and cur[r]==f,'destination chart') + qe=q.denominator.bit_length()-1;need(q.denominator==1<0 and sum(helpers.values())==527,'all productive helper inputs') + digest=sha256(json.dumps(rows,sort_keys=True,separators=(',',':')).encode()).hexdigest() + return dict(paid=dict(sorted(paid.items())),helpers=dict(sorted(helpers.items())),owned_peak=peak,owned_lifetimes=lifetimes,endpoint_rows=n,endpoint_scalar_entries=n*n,endpoint_digest=digest,opcodes=dict(sorted(scalar_count.items()))) +def histories(w,roles): + out={r:[] for r in roles};ordinal=0 + for i,e in enumerate(w['program']): + if e[0]=='MOVE': + if e[1] in out:out[e[1]].append(dict(event=i,before_scalar=ordinal,source=e[2],target=e[3],rank=abs(len(w['frames'][e[3]])-len(w['frames'][e[2]])),private=e[4])) + else:ordinal+=1 + return out +def calculate(): + s=read('SOURCE-WORD.json.gz');w=read('CANDIDATE-WORD.json.gz');c=read('CANDIDATE.json') + need(set(s)==set(w),'schema fields') + for k in s: + if k!='program':need(s[k]==w[k],'fixed boundary '+k) + old=[(i,e) for i,e in enumerate(s['program']) if e[0]!='MOVE'];new=[(i,e) for i,e in enumerate(w['program']) if e[0]!='MOVE'] + need([scalar(e) for i,e in old]==[scalar(e) for i,e in new],'all scalar and owned operations in exact chronological order') + changes=[] + for ordinal,((oi,oe),(ni,ne)) in enumerate(zip(old,new)): + if oe!=ne:changes.append(dict(scalar_ordinal=ordinal,source_event=oi,candidate_event=ni,before=oe,after=ne)) + add_changes=[x for x in changes if x['before'][0]=='ADD'] + need(len(add_changes)==6 and {x['source_event'] for x in add_changes}=={10461,10462,13970,15479,15639,15640},'exact six ADD chart edits') + need(len(changes)==21 and sum(x['before'][0]=='SCALE' for x in changes)==15,'fifteen additional SCALE chart retimings') + roles=sorted({r for x in changes for r in (x['before'][1:3] if x['before'][0]=='ADD' else x['before'][1:2])}) + a=audit(s);b=audit(w);need(a['helpers']==b['helpers'] and a['endpoint_digest']==b['endpoint_digest'],'same productive operator') + delta=Counter(b['paid']);delta.subtract(a['paid']);delta={k:v for k,v in sorted(delta.items()) if v} + need(delta=={1:2,2:-3,3:1,4:-1,5:1},'literal paid histogram delta') + # Real mutants exercise typing, scalar coefficient, and overwrite/clear lifecycle. + from copy import deepcopy + mutants=[] + for name,which,update in [('wrong_scalar',changes[0]['candidate_event'],lambda e:e.__setitem__(3,'2')),('wrong_chart',changes[0]['candidate_event'],lambda e:e.__setitem__(-1,335))]: + bad=deepcopy(w);update(bad['program'][which]) + try:audit(bad) + except ValueError as exc:mutants.append(dict(name=name,rejected=True,reason=str(exc))) + else:raise ValueError('mutant accepted '+name) + bad=deepcopy(w);j=next(i for i,e in enumerate(bad['program']) if e[0]=='CLEAR');bad['program'].pop(j) + try:audit(bad) + except ValueError as exc:mutants.append(dict(name='omit_owned_clear',rejected=True,reason=str(exc))) + else:raise ValueError('owned mutant accepted') + return dict(schema='p104-alpha-peer/1',status='PASS_SCALAR_AND_TYPED_BOUNDARIES_NOT_NATIVE_PHASE_OR_COMPLETE_PRICE',source_pins=PINS,before=a,after=b,paid_delta=delta,changes=changes,transport_histories={'before':histories(s,roles),'after':histories(w,roles)},mutation_controls=mutants,allwidth_scope='Each field stores Phi_frame^{tensor f} times its logical row. Exact chart-changing native MOVE interfaces and same-chart ADD/SCALE/COPY imply every positive field width with owner coefficients applied once. Native absolute-phase lowering is verified separately by the parent; this checker does not grant it or complete caller pricing.') +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args();result=json.loads(json.dumps(calculate(),sort_keys=True));encoded=json.dumps(result,sort_keys=True,indent=2)+'\n';receipt=ROOT/'RECEIPT.json' + if a.write:receipt.write_text(encoded) + else:need(json.loads(receipt.read_text())==result,'frozen receipt') + print(json.dumps({'status':'PASS','science_sha256':sha256(json.dumps(result,sort_keys=True,separators=(',',':')).encode()).hexdigest(),'paid_delta':result['paid_delta'],'rows':result['after']['endpoint_rows'],'native_phase':'SEPARATE_PARENT_CHECK','full_pricing':'SEPARATE_PARENT_CHECK'},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/p104-joint-contact/peer/inputs/CANDIDATE-WORD.json.gz b/research/p104-joint-contact/peer/inputs/CANDIDATE-WORD.json.gz new file mode 100644 index 0000000000..bb4064cdef Binary files /dev/null and b/research/p104-joint-contact/peer/inputs/CANDIDATE-WORD.json.gz differ diff --git a/research/p104-joint-contact/peer/inputs/CANDIDATE.json b/research/p104-joint-contact/peer/inputs/CANDIDATE.json new file mode 100644 index 0000000000..f54fa5aadf --- /dev/null +++ b/research/p104-joint-contact/peer/inputs/CANDIDATE.json @@ -0,0 +1,148 @@ +{ + "WORD_sha256": "535106a3caee2bc849b5d14438282ee211bafd31fc3d28e10137647673bbd15c", + "after": { + "1": 2430, + "2": 554, + "3": 390, + "4": 111, + "5": 108, + "6": 17, + "7": 13, + "9": 1 + }, + "before": { + "1": 2428, + "2": 557, + "3": 389, + "4": 112, + "5": 107, + "6": 17, + "7": 13, + "9": 1 + }, + "changes": [ + { + "before": [ + "ADD", + 297, + 303, + "1", + 335 + ], + "binary_node": 9829, + "new_basis": [ + 145 + ], + "new_frame": 17, + "source_event": 10461 + }, + { + "before": [ + "ADD", + 303, + 297, + "-1/2", + 335 + ], + "binary_node": 9830, + "new_basis": [ + 145 + ], + "new_frame": 17, + "source_event": 10462 + }, + { + "before": [ + "ADD", + 152, + 297, + "-1/2", + 335 + ], + "binary_node": 11927, + "new_basis": [ + 145 + ], + "new_frame": 17, + "source_event": 13970 + }, + { + "before": [ + "ADD", + 198, + 319, + "1", + 915 + ], + "binary_node": 12510, + "new_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "new_frame": 207, + "source_event": 15479 + }, + { + "before": [ + "ADD", + 205, + 198, + "1", + 915 + ], + "binary_node": 12591, + "new_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "new_frame": 207, + "source_event": 15639 + }, + { + "before": [ + "ADD", + 198, + 205, + "-1/2", + 915 + ], + "binary_node": 12592, + "new_basis": [ + 2, + 5, + 8, + 17, + 33, + 65, + 129, + 257 + ], + "new_frame": 207, + "source_event": 15640 + } + ], + "instructions": 25310, + "paid_delta": { + "1": 2, + "2": -3, + "3": 1, + "4": -1, + "5": 1 + }, + "scalar_order_identical": true, + "source_WORD_sha256": "a1e416add9d2bb44fce923111ebc50513e5d845e56aabe214f2f0bc7d5f2b45d", + "source_commit": "18968423711fd902aaee1099979497d55603e1dc", + "status": "CANDIDATE_NOT_YET_NATIVE_VERIFIED" +} diff --git a/research/p104-joint-contact/peer/inputs/SOURCE-WORD.json.gz b/research/p104-joint-contact/peer/inputs/SOURCE-WORD.json.gz new file mode 100644 index 0000000000..1ce96b0130 Binary files /dev/null and b/research/p104-joint-contact/peer/inputs/SOURCE-WORD.json.gz differ diff --git a/research/p104-joint-contact/pricing.py b/research/p104-joint-contact/pricing.py new file mode 100644 index 0000000000..ef78de99ff --- /dev/null +++ b/research/p104-joint-contact/pricing.py @@ -0,0 +1,156 @@ +"""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 prepared for thu-nmrc with substantial OpenAI Codex assistance. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00304153'), Q('.0030415305') +PREVIOUS = Q('.00304117') + + +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()) == 12814 and sum(paid.values()) == 69912, '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) + 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 selected kappa') + t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18 + 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**10),Q(97,100) + 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),1000 + 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') + 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':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA],'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, + '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':1, + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-joint-contact/verify.py b/research/p104-joint-contact/verify.py new file mode 100644 index 0000000000..349faeac26 --- /dev/null +++ b/research/p104-joint-contact/verify.py @@ -0,0 +1,90 @@ +"""Complete conditional P104 successor; the selected record is not changed. + +Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0. +Predecessor construction, native, caller, interval and outer proofs retain credit. +""" +import argparse +from collections import Counter +from copy import deepcopy +from hashlib import sha256 +import gzip,json +from pathlib import Path +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +from common import supplier,need +import construct + +def rejected(fn): + try: + fn() + except ValueError as error: + return str(error) + raise ValueError('Semantic mutant was accepted') + +def run(): + with supplier()as(root,L,C,R): + P=L.load(HERE/'pricing.py','p104_joint_pricing') + base=L.construct() + need(base==L.read(root/'research/p104-productive-controller/WORD.json.gz'),'Reconstructed full credited source') + source=R.construct(base) + need(source==L.read(root/'research/p104-full-frame-contact/WORD.json.gz'),'Reconstructed exact PR5545 source') + baseline=L.replay(source) + word=construct.construct(source) + local=L.replay(word);columns=L.reverse_columns(word) + need(local['helpers']==baseline['helpers'],'All 527 productive helper targets retained') + delta=Counter(local['paid']);delta.subtract(baseline['paid']) + delta={r:n for r,n in delta.items()if n} + need(delta=={1:2,2:-3,3:1,4:-1,5:1},'Exact coupled contact invoice') + need(sum(delta.values())==sum(r*n for r,n in delta.items())==0,'Call count and rank mass retained') + peer=L.load(HERE/'peer/check.py','p104_joint_independent_peer') + peer_result=json.loads(json.dumps(peer.calculate(),sort_keys=True)) + need(peer_result==L.read(HERE/'peer/RECEIPT.json'),'Independent exact scalar/frame receipt') + need(peer.read('SOURCE-WORD.json.gz')==source and peer.read('CANDIDATE-WORD.json.gz')==word,'Independent checker audits this exact pair of words') + print('PASS source reconstruction, all743 rows, reverse columns, independent integer peer and both coupled invoices',flush=True) + native=L.native(word) + controller=C.construct() + need(controller==L.read(root/'research/p104-productive-controller/CONTROLLER.json'),'Exact complete caller') + physical=C.physical(controller,word) + print('PASS every native map and phase, all527 helpers, all104 ports and complete265-axis caller',flush=True) + costs=P.run(local,native,controller,physical) + controls=C.controls(controller) + bad=deepcopy(word) + event=next(e for e in bad['program']if e==['ADD',297,303,'1',17]);event[-1]=335 + controls['one_operand_or_contact_left_at_old_chart']=rejected(lambda:L.replay(bad)) + bad=deepcopy(word) + event=next(e for e in bad['program']if e==['ADD',297,303,'1',17]);event[3]='2' + controls['wrong_butterfly_coefficient']=rejected(lambda:L.replay(bad)) + bad=deepcopy(local);bad['paid'][1]-=1 + controls['uncharged_recursive_call']=rejected(lambda:P.assemble(bad,native,controller,physical)) + bad=deepcopy(source);bad['program'][10461][3]='2' + controls['stale_source_or_changed_read']=rejected(lambda:construct.construct(bad)) + result={'status':'PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153', + 'source_commit':'18968423711fd902aaee1099979497d55603e1dc', + 'retained_source_files':33,'local_paid_delta':delta, + 'complete_paid_delta':{r:18*n for r,n in delta.items()}, + 'local':local,'separate_columns':columns,'native':native, + 'independent_peer_science_sha256':sha256(json.dumps(peer_result,sort_keys=True,separators=(',',':')).encode()).hexdigest(), + 'physical_caller':physical,'complete_cost':costs,'negative_controls':controls, + 'limits':['The five framework assumptions retained by PR5544/5545 remain.', + 'The uniform compiler word and complete rounded multiplier are not materialized.', + 'No independent human or proof-kernel acceptance, selected promotion, or core-contributor status is claimed.']} + return P.encode(result),word + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--write',action='store_true');args=parser.parse_args() + result,word=run() + for name,data in [('RESULT.json',result),('WORD.json.gz',word)]: + path=HERE/name + if args.write: + raw=(json.dumps(data,sort_keys=True,indent=None if name.endswith('.gz')else 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)==data,'Saved semantic artifact '+name) + print(result['status'],flush=True) + print(json.dumps({k:result['complete_cost'][k]for k in ('kappa','gain','raw_root_interval','productive_fields','paid_calls')},sort_keys=True),flush=True) + +if __name__=='__main__': + main()