From 295b00764305694b3c510d3b0bebc2ab024a7809 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Fri, 23 Oct 2026 23:09:27 -0500 Subject: [PATCH] Improve complete BIT saving with nine owned helper relations --- research/bit-nine-owned-relations/PROOF.md | 184 ++ research/bit-nine-owned-relations/README.md | 89 + research/bit-nine-owned-relations/RESULT.json | 1962 +++++++++++++++++ .../bit-nine-owned-relations/SOURCES.json | 96 + research/bit-nine-owned-relations/TASK.json | 71 + research/bit-nine-owned-relations/VERIFY.json | 42 + .../bit-nine-owned-relations/WORD.json.gz | Bin 0 -> 88156 bytes research/bit-nine-owned-relations/local.py | 249 +++ research/bit-nine-owned-relations/price.py | 232 ++ research/bit-nine-owned-relations/verify.py | 92 + 10 files changed, 3017 insertions(+) create mode 100644 research/bit-nine-owned-relations/PROOF.md create mode 100644 research/bit-nine-owned-relations/README.md create mode 100644 research/bit-nine-owned-relations/RESULT.json create mode 100644 research/bit-nine-owned-relations/SOURCES.json create mode 100644 research/bit-nine-owned-relations/TASK.json create mode 100644 research/bit-nine-owned-relations/VERIFY.json create mode 100644 research/bit-nine-owned-relations/WORD.json.gz create mode 100644 research/bit-nine-owned-relations/local.py create mode 100644 research/bit-nine-owned-relations/price.py create mode 100644 research/bit-nine-owned-relations/verify.py diff --git a/research/bit-nine-owned-relations/PROOF.md b/research/bit-nine-owned-relations/PROOF.md new file mode 100644 index 0000000000..217cee7af0 --- /dev/null +++ b/research/bit-nine-owned-relations/PROOF.md @@ -0,0 +1,184 @@ +# Boundary proof and complete BIT cost + +## 1. Source and owned input code + +Use the PR589 word retained at the source commit in SOURCES.json. It has +111 X fields, 111 Y fields, 439 helpers and one owned COPY centre. The +logical main map is `(X,Y) -> (X,Y+X)` over GF(2). Each helper has the +identity logical endpoint. The source forward and reverse words have +this same logical map. + +Replay the source records in reverse order over the vector space with +661 independent input symbols. Each of its nine COPY entries is a +linear form in these symbols. Reduce these nine forms by helper columns. +The resulting pivot helpers are + +```text +222, 223, 224, 225, 226, 228, 230, 231, 233. +``` + +Each reduced form contains its own pivot and no other pivot. Every field +in its support has the full entrance frame. The relation rows are saved +in RESULT.json and are derived again from the source during every run. + +Own these nine helpers. Clear each at entry and XOR its other relation +terms into it. The nine forms are then zero. These operations use a +common frame and leave all 652 retained input fields unchanged. A +chronological replay of the original reverse word now proves that every +COPY value is zero. The copy centre stays zero. Nine rank-one moves are +also on zero values. Replace only these moves by zero frame changes. +Clear the nine owned helpers at exit, and return the centre to its empty +frame. This gives a map on arbitrary retained inputs with all owned exit +fields zero. The entry clears make the result independent of arbitrary +initial values in owned storage. + +The exact new local paid profile is + +```text +{1:1314, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:10}. +``` + +The productive helper profile is `{8:430}`. There are no new nonzero +native maps. The original rank-one and rank-seven jobs are removed in +nine pairs. Each pair loses one rank-eight target. The fixed field count +remains 662; no new physical field is required. + +## 2. Why one reverse word serves both directions + +The logical involution alone is insufficient. Check the physical address +maps as well. For a source port let P be its rank-one rational projector, +K=I-P, Q=D_P, S=D_K, and R=D_I. Here D denotes the source two-bank +interchange, with its fixed second-bank reversal included. These address +permutations commute, square to I, and satisfy QS=R. + +In this paragraph Q, S and R denote their induced data-permutation +operators. Let M be the two-field XOR shear, with block rows `(I,0)` +and `(I,I)`. The source forward physical operator is + +```text +diag(R,S) M diag(Q,I) = [[S,0],[R,S]]. +``` + +Its reverse physical operator is + +```text +diag(Q,I) M diag(R,S) = [[S,0],[R,S]]. +``` + +Both products therefore give the same physical endpoint. This endpoint +is an involution over GF(2), since RS+SR=0. Each retained helper has +endpoint D_I, also an involution. Thus the new reverse implementation +replaces either direction of the original local call with the same +caller port and role assignments. No new query, route or native map is +needed for this replacement. + +The verifier checks the source entrance line and exit complement for +every port. It checks the rational address identities `D_I D_P=D_K` +and `D_P^2=D_K^2=I`. These are identities of address matrices. The block +XOR calculation above is an identity of induced data operators; it does +not identify addition of address matrices with addition of data operators. + +## 3. Native interfaces and all column multiplicities + +All nonzero native transitions are retained source transitions. The +verifier rebuilds every source projector over the rationals and checks +both nesting products and the rank difference for each transition pair. +For each of the 111 ports it builds an exact complement basis and a +15-dimensional route. It checks that the route is an involution, fixes +the central line, and sends the local full projector to the required +line-plus-fresh-stage projector. + +For column multiplicity f, tensor each head-space projector and route +with I_f. The same products, inclusions and involutions hold. The entry +code consists of pointwise XORs and clears in a common full frame. Its +relations hold on arbitrary data arrays. The complete finite program +therefore has the same native boundary for every f under the inherited +all-column and owned-erasure premises. + +Apply the retained delayed-cover bridge only after the entire finite +program is compiled. Its one common external weight is the same for all +fresh roles. All pointwise XORs commute with that weight. The retained +whole-fibre routes preserve independent data. The new code adds no +right-route symbol, nonzero native map or denominator. This argument +retains the source compiler and native realization premises; the finite +rational tests alone do not prove them. + +## 4. Complete controller invoice + +Replay every physical event in the source p16/a7 BIT controller over the +GF(2) group ring. Verify its literal scalar boundaries and all 32 +independent main inputs per port. There are eighteen full calls and +fifteen query shears. Replace every full call by the new word, using +Section 2. Leave each thin query and idle transform in place. + +Let P_old, T_old and P_new, T_new be the full paid and target histograms. +The exact differences are + +```text +P_new - P_old = -162 H1 -162 H7 +T_new - T_old = -162 H8. +``` + +Here Hr denotes one rank-r job or target. The new total is 57,231 paid +jobs and 11,292 productive fields. The paid rank mass is 215,457 and the +target rank mass is 216,210. The surplus is 753, as before. The verifier +reconstructs both complete invoices from the literal event list; it does +not subtract a proposed saving from a stored total. + +For every 00`. An equivalent certificate for the signed paid-minus- +target difference is the hinge sum `sum(delta_r*min(r,k))`: its values +at k=1,7,8 are -162,-162,0. All tail values are zero. This charges every +lost target and proves a strict improvement for the concave rank power. + +Two rational interval engines check the new moment. The raw moment has +a positive margin at 0.003472070044 and a negative margin at +0.003472070045. This is a certified crossing, not an optimum over other +words or controller classes. + +## 5. Compiler, cover and ordinary conversion + +The new tested saving is 0.0034678 and the uniform saving is 0.0034668. +Keep the source tensor power 1024, cutoff 17, floor 18, second-moment +parameter 1/5 and reserve 1/250000. The exact interval checks give the +charged first-moment ratio below `1-reserve`, the tail ratio below +31/32 and the rounding ratio below 19/20. Both decay bounds after 128 +steps are below 1/16. The completion surplus is positive, `17^64<18^63`, +and every target rank is below 256. RESULT.json records the exact H0 and +strict H1 thresholds. The winning uniform word is not materialized. + +Keep the source cover loss 0.000009. The saving after cover is 0.0034578. +Use an odd prime `q>2^26*N^5` that avoids all fixed denominators and rank +witnesses. Keep atom fraction 0.004 and old ordinary saving 0.0000384599. +The new ordinary saving is + +```text +(1-0.004)*0.0034578 + 0.004*0.0000384599 = 0.0034441226396. +``` + +The strict admitted endpoint is 0.00344412. At the same compiler gaps, +cover loss and atom fraction, the old word gives 0.0034363538396. The +matched gain is exactly 0.0000077688. This comparison does not credit the +new relations for the old source's unused conservative headroom. + +The new local word has 25,891 pointwise records. This is 1,568 more than +the source's 24,305 XORs and eighteen COPY entry/exit records. Add all +1,568 records to the inherited complete local allowance of 1,000,000. +The new local allowance is 1,001,568. With all eighteen calls, thin +queries, physical events and boundary operations, the complete raw +nonrecursive allowance is 19,170,192, below the retained 10^9 allowance. +The new code uses only unit XOR coefficients, adds no denominator and +no storage field, and retains the source tape and cover obligations. + +## 6. Complete multiplication scope + +Use the pinned PR5398 outer parameters and replace only their ordinary +BIT saving by 0.00344412. All 54 strict and four functional predicates +pass. The actual BIT stock exponent is positive and strictly below the +active group exponent, which is below one. The complete multiplication +endpoint remains 0.00302728823. The complex supplier still binds. + +This is a complete conditional BIT component improvement. It is not a +new complete multiplication bound, a selected-frontier change, a formal +proof, or an independent replay of the consumed complex construction. +All five inherited premise classes remain explicit in RESULT.json. diff --git a/research/bit-nine-owned-relations/README.md b/research/bit-nine-owned-relations/README.md new file mode 100644 index 0000000000..f2914f37b9 --- /dev/null +++ b/research/bit-nine-owned-relations/README.md @@ -0,0 +1,89 @@ +# Nine owned BIT helper relations + +This conditional construction raises the ordinary BIT saving from +**0.0034363538396 to 0.0034441226396** at matched compiler and cover +parameters. It admits the strict endpoint **0.00344412**. The complete +multiplication kappa does not increase: the complex supplier still binds. + +The reverse PR589 word has nine COPY values that are linear forms of its +initial full-frame fields. Own one helper for each independent form and +set all nine forms to zero. This removes nine rank-one transitions and +nine rank-seven COPY jobs per local call. It also removes nine rank-eight +productive helper targets. All 652 retained inputs remain independent. +The ten owned fields, including the old COPY centre, accept arbitrary +entry data and finish at zero. + +[PROOF.md](PROOF.md) gives the local boundary argument, the physical +involution that permits use at all eighteen full calls, the tensor lift, +and the complete cost. [RESULT.json](RESULT.json) contains the exact +receipt. [WORD.json.gz](WORD.json.gz) contains the emitted program. +[SOURCES.json](SOURCES.json) pins all thirteen live inputs at base +`d277c97824e50782da6adbc486ca3c76c8fc687e`. The selected record in that +manifest is historical provenance. This package does not change it. + +The complete p16/a7 controller has 57,231 paid jobs and 11,292 productive +fields. Its change is minus 162 rank-one jobs, minus 162 rank-seven jobs, +and minus 162 rank-eight targets. Its rank surplus remains 753. The raw +moment crossing lies strictly between 0.003472070044 and 0.003472070045. +The complete scalar and route allowance remains below 10^9. + +## Reproduce + +Use CPython 3.12 and its standard library. From the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/bit-nine-owned-relations +python3.12 -O -B research/bit-nine-owned-relations/verify.py +``` + +The verifier prints: + +```text +PASS_BIT_NINE_OWNED_RELATIONS_00344412_NO_NEW_MULTIPLICATION_KAPPA +``` + +It authenticates every live source, rebuilds the word, checks all symbolic +input rows, and replays each of the 662 input columns with separate +Boolean state. It checks rational projectors and all 111 port charts, +the literal controller, all targets and paid jobs, two exact moment +engines, the compiler tail, the cover loss, the ordinary BIT conversion, +and the unchanged outer arithmetic. It rejects missing entry or exit +clears, a changed relation, a nonzero free transition, a missing target +debit, and the old word at the new saving. + +## Scope + +The native all-column, owned-erasure, compiler, precision/tape, and +analytic-recovery premises remain conditional. The source delayed-cover +argument supplies the common weight and recursive interface. The finite +checks do not materialize the full GL cover, the winning uniform word, +or the complete integer multiplier. No Lean or proof-kernel check is +included. The outer arithmetic consumes the pinned PR5398 receipt; it +does not replay that complex construction. No global optimum is claimed. + +## Open next questions + +A further BIT gain needs a new relation space after all nine COPY jobs +are removed. Check active claims first, then charge each lost target +against the full word. The current full-history searches supply no such +additional gain. A complete multiplication gain needs a cheaper complex +supplier with a complete caller and cost. This package supplies neither. +[TASK.json](TASK.json) records the scope and these limits. + +## Credit + +DreamingOfClouds supplied [PR #589](https://github.com/CrocSwap/integer-mult-bounds/pull/589), +the retained two-transport word. eumemic supplied +[PR #555](https://github.com/CrocSwap/integer-mult-bounds/pull/555), the +punctured 111-port, 439-helper construction, from the credited earlier +word and port construction. Their source notices remain unchanged. +Cinna Davis supplied the query-thinned controller, the native BIT binding, +and the delayed-cover bridge. The exact compiler and tail work follows +zxv and the retained mixed-target recursion of Jacob Alan Sussman. +Ali Romman's [PR #5383](https://github.com/CrocSwap/integer-mult-bounds/pull/5383) +supplies the prior owned-helper method. The unchanged complex comparison +comes from [PR #5398](https://github.com/CrocSwap/integer-mult-bounds/pull/5398). +The exact consumed source paths and pins are in SOURCES.json. + +Prepared by Ali Romman with substantial OpenAI Codex assistance; no +subagents. New work is Apache-2.0. All predecessor notices are retained. diff --git a/research/bit-nine-owned-relations/RESULT.json b/research/bit-nine-owned-relations/RESULT.json new file mode 100644 index 0000000000..b3fd1f0fa2 --- /dev/null +++ b/research/bit-nine-owned-relations/RESULT.json @@ -0,0 +1,1962 @@ +{ + "complete_cost": { + "binding_constraint": "The complex supplier remains below this BIT saving.", + "budgets": { + "added_pointwise_records_per_call": 1568, + "complete_raw_nonrecursive": 19170192, + "inherited_source_local_upper": 1000000, + "local_complete_upper": 1001568, + "local_scalar": 25891, + "raw_allowance": 1000000000 + }, + "complete_multiplication_kappa_improvement": false, + "concave_order_certificate": { + "1": -162, + "7": -162, + "8": 0 + }, + "controller": { + "full_calls": 18, + "parent_inputs_per_port": 32, + "physical_events": 154, + "thin_calls": 15 + }, + "negative_controls": { + "missing_target_debit": "Every paid job and earned target must match the literal word", + "old_word_at_new_saving": "Rejected by the exact raw moment" + }, + "new_compiler": { + "H0": 3764063437, + "H1": 26102274310221, + "alpha": { + "lower": "0.999995697975360862052844540831", + "upper": "0.999995697975360862052844540832" + }, + "cutoff": 17, + "delta": { + "lower": "0.941917605188527740239545244446", + "upper": "0.941917605188527740239545244447" + }, + "floor": 18, + "gamma": { + "lower": "0.958354812695517905511855681272", + "upper": "0.958354812695517905511855681273" + }, + "normalized_surplus_lower": "68719461047/16845935476736", + "reserve": "1/250000", + "tensor_power": 1024, + "tested": "17339/5000000", + "uniform": "8667/2500000", + "uniform_N": "2^26102274310221", + "winning_word_materialized": false + }, + "new_raw_root": [ + "868017511/250000000000", + "694414009/200000000000" + ], + "old_compiler": { + "H0": 3755884544, + "H1": 25986965159937, + "alpha": { + "lower": "0.999995735238059506641600561767", + "upper": "0.999995735238059506641600561768" + }, + "cutoff": 17, + "delta": { + "lower": "0.949707924144871179442776557218", + "upper": "0.949707924144871179442776557219" + }, + "floor": 18, + "gamma": { + "lower": "0.957429821066420278606254392110", + "upper": "0.957429821066420278606254392111" + }, + "normalized_surplus_lower": "68719461047/16845935476736", + "reserve": "1/250000", + "tensor_power": 1024, + "tested": "173/50000", + "uniform": "3459/1000000", + "uniform_N": "2^25986965159937", + "winning_word_materialized": false + }, + "old_raw_root": [ + "866062243/250000000000", + "3464248973/1000000000000" + ], + "ordinary_BIT": { + "admitted": "86103/25000000", + "after_cover": "17289/5000000", + "atom": "1/250", + "gain_at_matched_parameters": "9711/1250000000", + "new_ordinary": "8610306599/2500000000000", + "old_ordinary": "8590884599/2500000000000", + "prime_rule": "Odd q > 2^26*N^5, avoiding all fixed denominators and rank witnesses" + }, + "outer_at_unchanged_complex_endpoint": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "370842808874470224559/122500000000000000000000", + "fused_gaussian": "370842808873410673677/122500000000000000000000", + "global_coordinate_router": "423820353/140000000000", + "group_bit_router": "296674247238728538941/98000000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "370842808699470224559/122500000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "50136467808874470224559/122500000000000000000000" + }, + "parameters": { + "a": "423820353/140000000000", + "b": "1059550883/350000000000", + "beta": "699999999997/700000000000", + "bit_saving": "86103/25000000", + "cap_xi": "111386467808699470224559/122500000000000000000000", + "complex_uniform_saving": "2119101767/700000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "302728823/100000000000", + "lambda_": "199394542353/200000000000", + "lambda_prime": "174470224559/175000000000", + "layout": "1/700000000000", + "q": "529775441/175000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "37841103/12500000000" + }, + "strict_checks": { + "actual_bit_above_effective": "58356447/140000000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "11113532191563029775441/61250000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "699470224559/122500000000000000000000", + "cap_above_band": "50136467808699470224559/122500000000000000000000", + "cap_below_cell": "11113532191125529775441/122500000000000000000000", + "cap_below_phase_cell_power": "133613532191300529775441/122500000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "9877949117/350000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "698410673677/122500000000000000000000", + "gaussian_above_main": "86970224559/61250000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "698728538941/98000000000000000000000", + "group_gauge_power_slack": "11113532191554279775441/61250000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "697880898237/700000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "648158905400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "698940449117/245000000000000000000000", + "leaf_saving_above_effective": "348940449117/245000000000000000000000", + "main_transform_above_kappa": "524470224559/122500000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "53897880898243/700000000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "348940449119/350000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "698940449117/245000000000000000000000", + "q_positive": "529775441/175000000000", + "short_record_fallback": "348940449117/350000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "49765625000699470224559/122500000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "paid": { + "1": 25317, + "14": 444, + "2": 24156, + "21": 444, + "28": 444, + "3": 1422, + "35": 444, + "4": 792, + "42": 444, + "49": 444, + "5": 1836, + "56": 444, + "6": 198, + "63": 222, + "7": 180 + }, + "paid_count": 57231, + "rank_bill": 215457, + "rank_credit": 216210, + "signed_delta": { + "1": -162, + "7": -162, + "8": 162 + }, + "target_count": 11292, + "targets": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "8": 7740 + } + }, + "limits": [ + "The complex supplier still limits the complete multiplication bound.", + "Native all-column, owned-erasure, compiler, precision/tape and analytic recovery premises remain conditional.", + "The full GL cover, winning uniform word and complete integer multiplier are not materialized.", + "No Lean or proof-kernel check is included." + ], + "local": { + "arbitrary_owned_entries": 10, + "events": 28802, + "helpers": { + "8": 430 + }, + "maximum_binary_row_weight": 264, + "native": { + "all_f_rule": "Source projectors tensor I_f; the source address involutions and all GF(2) identities stay exact.", + "fresh_port_routes": 111, + "full_GL_cover_executed": false, + "main_involution_ports": 111, + "nested_transition_pairs": 2386, + "new_nonzero_native_maps": 0, + "rational_projectors": 636 + }, + "negative_controls": { + "changed_relation": "Only a zero value can change frame for free", + "missing_owned_entry_clear": "Only a zero value can change frame for free", + "missing_owned_exit_clear": "Every retained and arbitrary owned entry column", + "unearned_free_transition": "Only a zero value can change frame for free" + }, + "paid": { + "1": 1314, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 10 + }, + "relation_basis": { + "222": [ + 8, + 9, + 10, + 11, + 12, + 13, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 46, + 47, + 48, + 49, + 50, + 51, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 222, + 239, + 243, + 245, + 251, + 256, + 261, + 265, + 269, + 270, + 272, + 273, + 281, + 282, + 285, + 286, + 291, + 292, + 295, + 297, + 298, + 299, + 301, + 305, + 309, + 313, + 315, + 317, + 318, + 321, + 322, + 325, + 327, + 329, + 330, + 335, + 336, + 340, + 344, + 346, + 347, + 348, + 349, + 351, + 352, + 353, + 354, + 355, + 357, + 358, + 360, + 364, + 368, + 371, + 375, + 376, + 377, + 378, + 379, + 381, + 383, + 385, + 386, + 387, + 388, + 394, + 396, + 403, + 404, + 406, + 410, + 411, + 416, + 420, + 422, + 426, + 427, + 431, + 432, + 433, + 435, + 436, + 438, + 440, + 442, + 443, + 454, + 460, + 462, + 465, + 466, + 467, + 474, + 476, + 477, + 478, + 486, + 488, + 492, + 495, + 496, + 507, + 509, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ], + "223": [ + 0, + 3, + 5, + 6, + 14, + 16, + 18, + 20, + 22, + 23, + 26, + 27, + 31, + 33, + 35, + 37, + 40, + 41, + 44, + 45, + 47, + 48, + 50, + 53, + 54, + 55, + 56, + 60, + 61, + 63, + 65, + 69, + 70, + 71, + 72, + 74, + 76, + 77, + 79, + 82, + 83, + 84, + 85, + 88, + 90, + 93, + 95, + 96, + 97, + 102, + 104, + 105, + 107, + 110, + 223, + 240, + 241, + 246, + 247, + 249, + 250, + 251, + 258, + 260, + 266, + 268, + 269, + 274, + 276, + 278, + 280, + 282, + 284, + 285, + 291, + 292, + 297, + 298, + 301, + 305, + 307, + 313, + 317, + 321, + 322, + 327, + 330, + 331, + 332, + 334, + 336, + 338, + 340, + 341, + 342, + 347, + 348, + 349, + 352, + 354, + 357, + 360, + 365, + 368, + 369, + 376, + 378, + 381, + 385, + 387, + 388, + 392, + 394, + 403, + 406, + 408, + 410, + 411, + 416, + 417, + 419, + 420, + 421, + 422, + 423, + 425, + 432, + 435, + 436, + 437, + 438, + 439, + 440, + 449, + 460, + 462, + 464, + 466, + 467, + 472, + 473, + 476, + 478, + 484, + 492, + 495, + 496, + 499, + 504, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ], + "224": [ + 0, + 1, + 6, + 7, + 9, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 25, + 27, + 28, + 30, + 31, + 32, + 33, + 39, + 41, + 43, + 45, + 46, + 48, + 49, + 50, + 52, + 53, + 56, + 57, + 62, + 63, + 64, + 65, + 67, + 69, + 71, + 74, + 76, + 78, + 80, + 81, + 83, + 84, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 100, + 102, + 104, + 106, + 108, + 110, + 224, + 237, + 238, + 239, + 241, + 242, + 245, + 248, + 252, + 254, + 256, + 257, + 261, + 263, + 271, + 277, + 279, + 281, + 283, + 287, + 288, + 290, + 293, + 294, + 295, + 296, + 297, + 299, + 300, + 303, + 305, + 307, + 309, + 312, + 316, + 319, + 322, + 327, + 335, + 339, + 341, + 343, + 344, + 348, + 349, + 352, + 355, + 360, + 363, + 364, + 367, + 371, + 376, + 380, + 389, + 390, + 391, + 392, + 394, + 396, + 400, + 402, + 404, + 406, + 414, + 418, + 429, + 430, + 434, + 442, + 452, + 454, + 455, + 456, + 462, + 463, + 464, + 469, + 471, + 477, + 479, + 490, + 501, + 514, + 525, + 531, + 544, + 561, + 568, + 582, + 594, + 606, + 608, + 617, + 629, + 641, + 643, + 649 + ], + "225": [ + 1, + 2, + 5, + 6, + 11, + 12, + 13, + 14, + 16, + 19, + 21, + 24, + 25, + 26, + 27, + 30, + 32, + 35, + 37, + 40, + 41, + 42, + 43, + 47, + 48, + 49, + 51, + 53, + 54, + 55, + 56, + 59, + 60, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 75, + 77, + 79, + 82, + 83, + 86, + 87, + 88, + 90, + 92, + 94, + 98, + 99, + 102, + 103, + 106, + 107, + 110, + 225, + 227, + 240, + 243, + 247, + 249, + 250, + 259, + 266, + 267, + 268, + 276, + 278, + 282, + 288, + 297, + 304, + 305, + 307, + 308, + 320, + 328, + 331, + 332, + 334, + 338, + 341, + 342, + 347, + 351, + 353, + 354, + 356, + 357, + 360, + 368, + 371, + 377, + 379, + 381, + 391, + 392, + 393, + 394, + 401, + 403, + 405, + 408, + 410, + 413, + 416, + 417, + 423, + 424, + 425, + 427, + 435, + 437, + 440, + 443, + 447, + 449, + 451, + 455, + 457, + 458, + 461, + 466, + 467, + 472, + 476, + 484, + 486, + 492, + 499, + 504, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ], + "226": [ + 2, + 3, + 4, + 5, + 8, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 24, + 26, + 29, + 30, + 31, + 32, + 33, + 39, + 41, + 43, + 45, + 46, + 48, + 49, + 50, + 52, + 53, + 56, + 57, + 59, + 60, + 61, + 66, + 68, + 70, + 72, + 73, + 75, + 77, + 79, + 82, + 85, + 86, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 98, + 100, + 102, + 104, + 106, + 108, + 110, + 226, + 235, + 240, + 241, + 246, + 247, + 249, + 250, + 256, + 264, + 265, + 268, + 269, + 276, + 278, + 281, + 282, + 285, + 286, + 292, + 298, + 305, + 306, + 307, + 313, + 315, + 317, + 318, + 322, + 326, + 327, + 330, + 331, + 332, + 334, + 336, + 338, + 341, + 342, + 343, + 347, + 348, + 349, + 352, + 354, + 357, + 360, + 361, + 369, + 374, + 376, + 378, + 381, + 382, + 386, + 387, + 392, + 394, + 403, + 406, + 408, + 410, + 416, + 417, + 419, + 420, + 421, + 423, + 425, + 426, + 432, + 435, + 436, + 437, + 438, + 440, + 449, + 450, + 457, + 460, + 462, + 464, + 466, + 472, + 473, + 476, + 478, + 480, + 484, + 488, + 492, + 495, + 496, + 499, + 504, + 506, + 511, + 515, + 517, + 518, + 528, + 530, + 536, + 538, + 547, + 551, + 554, + 558, + 559, + 569, + 571, + 585, + 593, + 596, + 597, + 603, + 612, + 615, + 622, + 624, + 625, + 631, + 634, + 639, + 644, + 651, + 656, + 657 + ], + "228": [ + 0, + 3, + 5, + 6, + 8, + 10, + 12, + 13, + 14, + 15, + 20, + 21, + 22, + 24, + 27, + 29, + 32, + 33, + 34, + 35, + 39, + 41, + 42, + 44, + 46, + 47, + 48, + 53, + 55, + 57, + 59, + 60, + 64, + 65, + 68, + 69, + 72, + 75, + 76, + 79, + 80, + 83, + 85, + 87, + 88, + 89, + 92, + 93, + 96, + 98, + 100, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 228, + 239, + 240, + 243, + 245, + 247, + 251, + 256, + 261, + 265, + 266, + 268, + 269, + 270, + 273, + 276, + 278, + 281, + 282, + 285, + 286, + 288, + 291, + 292, + 295, + 297, + 299, + 301, + 304, + 305, + 308, + 309, + 313, + 315, + 317, + 318, + 321, + 322, + 325, + 327, + 329, + 330, + 332, + 334, + 335, + 336, + 338, + 340, + 342, + 344, + 347, + 348, + 349, + 351, + 352, + 353, + 354, + 355, + 364, + 368, + 371, + 375, + 376, + 377, + 378, + 379, + 383, + 386, + 387, + 388, + 391, + 393, + 394, + 396, + 401, + 403, + 404, + 405, + 406, + 410, + 411, + 413, + 416, + 417, + 420, + 422, + 423, + 425, + 426, + 427, + 431, + 432, + 435, + 436, + 437, + 438, + 440, + 442, + 443, + 447, + 451, + 454, + 455, + 457, + 460, + 461, + 462, + 465, + 466, + 467, + 472, + 474, + 476, + 477, + 478, + 484, + 486, + 488, + 492, + 495, + 496, + 499, + 504, + 507, + 509, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ], + "230": [ + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 14, + 17, + 18, + 21, + 22, + 25, + 26, + 29, + 30, + 33, + 34, + 37, + 38, + 41, + 42, + 45, + 46, + 49, + 51, + 52, + 53, + 55, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 74, + 75, + 78, + 79, + 82, + 85, + 86, + 89, + 90, + 93, + 94, + 97, + 98, + 101, + 102, + 104, + 105, + 108, + 109, + 230, + 239, + 240, + 243, + 245, + 247, + 262, + 266, + 267, + 268, + 271, + 276, + 278, + 282, + 285, + 288, + 293, + 295, + 304, + 305, + 308, + 324, + 330, + 332, + 334, + 335, + 337, + 338, + 342, + 346, + 351, + 357, + 358, + 360, + 365, + 369, + 370, + 373, + 375, + 377, + 379, + 383, + 385, + 391, + 393, + 394, + 401, + 403, + 404, + 405, + 410, + 415, + 417, + 423, + 425, + 427, + 433, + 435, + 436, + 437, + 443, + 444, + 447, + 451, + 453, + 454, + 455, + 457, + 461, + 468, + 470, + 471, + 472, + 475, + 484, + 486, + 487, + 499, + 504, + 510, + 517, + 528, + 558, + 559, + 584, + 598, + 603, + 616, + 622, + 634, + 640, + 651, + 658 + ], + "231": [ + 4, + 5, + 6, + 7, + 8, + 10, + 11, + 15, + 16, + 19, + 20, + 23, + 24, + 27, + 28, + 30, + 33, + 34, + 37, + 38, + 41, + 42, + 45, + 47, + 48, + 50, + 54, + 56, + 57, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 73, + 76, + 77, + 80, + 81, + 83, + 84, + 87, + 89, + 90, + 93, + 94, + 97, + 98, + 101, + 102, + 103, + 106, + 107, + 110, + 231, + 237, + 239, + 240, + 243, + 245, + 247, + 249, + 250, + 251, + 254, + 256, + 261, + 266, + 268, + 269, + 276, + 278, + 281, + 282, + 283, + 285, + 288, + 291, + 292, + 295, + 299, + 300, + 301, + 304, + 308, + 309, + 313, + 317, + 321, + 322, + 325, + 327, + 330, + 331, + 332, + 334, + 335, + 336, + 338, + 339, + 342, + 343, + 344, + 347, + 348, + 349, + 351, + 352, + 353, + 354, + 357, + 360, + 364, + 368, + 371, + 376, + 377, + 378, + 379, + 380, + 381, + 387, + 388, + 390, + 391, + 393, + 396, + 400, + 401, + 403, + 404, + 405, + 406, + 408, + 410, + 411, + 413, + 414, + 416, + 417, + 418, + 420, + 422, + 423, + 425, + 427, + 432, + 435, + 436, + 437, + 438, + 440, + 441, + 442, + 443, + 447, + 449, + 451, + 454, + 455, + 456, + 457, + 459, + 460, + 461, + 462, + 466, + 467, + 472, + 476, + 477, + 478, + 484, + 486, + 492, + 495, + 496, + 499, + 504, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ], + "233": [ + 9, + 11, + 14, + 17, + 19, + 20, + 23, + 24, + 26, + 29, + 30, + 33, + 35, + 36, + 39, + 40, + 42, + 45, + 46, + 50, + 52, + 53, + 55, + 58, + 59, + 61, + 63, + 64, + 66, + 67, + 69, + 72, + 73, + 76, + 78, + 79, + 82, + 84, + 87, + 88, + 91, + 93, + 94, + 97, + 98, + 100, + 103, + 106, + 108, + 109, + 233, + 240, + 241, + 243, + 247, + 249, + 250, + 251, + 266, + 268, + 269, + 276, + 278, + 282, + 285, + 288, + 291, + 292, + 297, + 301, + 304, + 305, + 307, + 308, + 313, + 317, + 319, + 321, + 327, + 330, + 331, + 332, + 334, + 336, + 338, + 341, + 342, + 347, + 348, + 351, + 352, + 353, + 354, + 357, + 360, + 368, + 371, + 376, + 377, + 378, + 379, + 381, + 387, + 388, + 391, + 392, + 393, + 394, + 401, + 403, + 405, + 406, + 408, + 410, + 411, + 413, + 416, + 417, + 420, + 422, + 423, + 425, + 427, + 432, + 435, + 436, + 437, + 438, + 440, + 443, + 447, + 449, + 451, + 455, + 457, + 460, + 461, + 463, + 464, + 466, + 467, + 472, + 476, + 478, + 484, + 486, + 492, + 495, + 496, + 499, + 504, + 511, + 517, + 528, + 547, + 551, + 558, + 559, + 585, + 597, + 603, + 615, + 622, + 634, + 639, + 651, + 657 + ] + }, + "removed": [ + [ + 2398, + "MOVE", + 472, + 1 + ], + [ + 2405, + "MOVE", + 473, + 1 + ], + [ + 2412, + "MOVE", + 474, + 1 + ], + [ + 2419, + "MOVE", + 475, + 1 + ], + [ + 2426, + "MOVE", + 476, + 1 + ], + [ + 2433, + "MOVE", + 477, + 1 + ], + [ + 2440, + "MOVE", + 478, + 1 + ], + [ + 2447, + "MOVE", + 479, + 1 + ], + [ + 2454, + "MOVE", + 480, + 1 + ], + [ + 4873, + "COPY", + 480, + 7 + ], + [ + 4938, + "COPY", + 479, + 7 + ], + [ + 4995, + "COPY", + 478, + 7 + ], + [ + 5052, + "COPY", + 477, + 7 + ], + [ + 5117, + "COPY", + 476, + 7 + ], + [ + 5182, + "COPY", + 475, + 7 + ], + [ + 5239, + "COPY", + 474, + 7 + ], + [ + 5296, + "COPY", + 473, + 7 + ], + [ + 5353, + "COPY", + 472, + 7 + ] + ], + "retained_inputs": 652, + "scalar_events": 25891, + "word_sha256": "265c58356ced52b4d4345b5872aa225db373e96739de6c8d90b087a900db3588" + }, + "separate_columns": { + "columns": 662, + "method": "One Boolean input at a time; bytearray state; no symbolic row algebra" + }, + "source_inputs_authenticated": 13, + "status": "PASS_BIT_NINE_OWNED_RELATIONS_00344412_NO_NEW_MULTIPLICATION_KAPPA" +} diff --git a/research/bit-nine-owned-relations/SOURCES.json b/research/bit-nine-owned-relations/SOURCES.json new file mode 100644 index 0000000000..ff523a2966 --- /dev/null +++ b/research/bit-nine-owned-relations/SOURCES.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "base_commit": "d277c97824e50782da6adbc486ca3c76c8fc687e", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-backward-controller-20261023/RESULT.json", + "usage": "input", + "git_blob": "32b2b214ae108046bb68a507939ecb8c28c4ba92", + "sha256": "9b65013f63f616f12f4bb4d96ac75429452fad8680cada4bfd570e001fcd9a34" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/249-records.bin", + "usage": "input", + "git_blob": "bdf9ab4ca0fd74cde6837f95f5f4e88133704e0e", + "sha256": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "usage": "input", + "git_blob": "a9a932b9268da28af9ba4bccdab205c5bcd50ad3", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/query-thinned-controllers/BIT-CONTROLLER.json", + "usage": "input", + "git_blob": "89c400d5970024b3debe870c36ce43889beed001", + "sha256": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d" + }, + { + "path": "research/query-thinned-controllers/PROOF.md", + "usage": "input", + "git_blob": "9068f429896112082664455ab00bab083c99d1d8", + "sha256": "5ade59641f2ed70d045d6f60e89db7d979b1d1e9967f3acbe5c56eac81312841" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "usage": "input", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950" + } + ] +} diff --git a/research/bit-nine-owned-relations/TASK.json b/research/bit-nine-owned-relations/TASK.json new file mode 100644 index 0000000000..742ca9f9c7 --- /dev/null +++ b/research/bit-nine-owned-relations/TASK.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 7, + "base_commit": "d277c97824e50782da6adbc486ca3c76c8fc687e", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "Own nine initial BIT helper relations in the PR589 reverse word; remove nine rank-one transitions and nine rank-seven COPY jobs; debit nine rank-eight helper targets; admit the complete BIT component at 0.00344412. The complete multiplication kappa does not increase.", + "scope_change_reason": "The user asked to generalize the owned-helper relation method. This applies the method to the current retained BIT supplier and keeps every retained helper autonomous. It does not change the abstract H2/K operation alphabet.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639", + "budget_minutes": 120, + "stop_rule": "Stop this package after the exact local endpoint, both source directions, complete BIT cost and source-bound replay pass. Do not claim a complete multiplication improvement from extra BIT headroom.", + "outcome": "completed", + "evidence": "RESULT.json, WORD.json.gz, exact row and separate column replays, rational native charts, full compiler/cover and outer arithmetic.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.", + "open_questions": [ + { + "question": "Can a different BIT relation space remove more paid work after all nine COPY jobs are zero?", + "why_it_matters": "A smaller BIT bill can support a future stronger complex supplier.", + "first_step": "Check active claims, then derive a new relation space from the emitted word and charge each lost target.", + "blocked_by": "The current nine COPY jobs are already removed; no additional saving is proved." + }, + { + "question": "Can a complete complex supplier exceed the new BIT endpoint?", + "why_it_matters": "The complex side still limits the complete multiplication exponent.", + "first_step": "Use a source-bound complex word with a complete caller and native bill.", + "blocked_by": "No such improvement is supplied by this package." + } + ], + "coordination": { + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639", + "distinct_scope": "BIT local helper relations; does not take the coupled complex caller in Discussion 4930." + } +} diff --git a/research/bit-nine-owned-relations/VERIFY.json b/research/bit-nine-owned-relations/VERIFY.json new file mode 100644 index 0000000000..ed003ddfa0 --- /dev/null +++ b/research/bit-nine-owned-relations/VERIFY.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/higher-moment-strictification/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-backward-controller-20261023/RESULT.json", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/249-records.bin", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/query-thinned-controllers/BIT-CONTROLLER.json", + "research/query-thinned-controllers/PROOF.md", + "research/query-thinned-controllers/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate exact sources; rebuild the owned program; check all symbolic rows and all 662 Boolean input columns; check rational frames and port routes; replay the p16 controller; verify both complete invoices, two exact moment engines, compiler, cover, ordinary BIT and unchanged outer endpoint; reject semantic mutations." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Repeat the same complete checks with Python assertions disabled." + } + ] +} diff --git a/research/bit-nine-owned-relations/WORD.json.gz b/research/bit-nine-owned-relations/WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..19caa85e458f03a0a48dc9453e67aed52fbcb0cd GIT binary patch literal 88156 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%0A2}_dD#~GwprOp4oYcifR3b5Q6k`pN*lE7 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 literal 0 HcmV?d00001 diff --git a/research/bit-nine-owned-relations/local.py b/research/bit-nine-owned-relations/local.py new file mode 100644 index 0000000000..8fb7f48ebd --- /dev/null +++ b/research/bit-nine-owned-relations/local.py @@ -0,0 +1,249 @@ +"""Own nine BIT helper relations and check all input columns. + +The source word is due to DreamingOfClouds, eumemic and their predecessors. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import struct +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = ROOT / 'research/kappa-rebuild/bit/sources/pr589-regenerated' +SIZE, PORTS = 661, 111 +OLD_PAID = {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19} +NEW_PAID = {1:1314, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:10} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, ROOT / path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def source(): + word = json.loads(gzip.decompress((SOURCE / 'WORD.json.gz').read_bytes())) + records = list(struct.iter_unpack('<6i', (SOURCE / 'records/249-records.bin').read_bytes())) + frames = json.loads((SOURCE / 'records/frames.json').read_text())['frames'] + return word, records, frames + + +def relations(word, records): + rows = [1 << i for i in range(SIZE)] + [0] + result = [] + for op, x, y, coefficient, frame, _ in reversed(records): + if op == 1 and coefficient & 1: + rows[x] ^= rows[y] + elif op == 3: + need(y == SIZE and rows[SIZE] == 0, 'Source COPY entrance') + result.append(rows[x]) + rows[SIZE] = rows[x] + elif op == 2: + need(y == SIZE and rows[x] == rows[SIZE], 'Source COPY exit') + rows[SIZE] = 0 + want = [(1 << i) ^ ((1 << (i-PORTS)) if PORTS <= i < 2*PORTS else 0) + for i in range(SIZE)] + [0] + need(rows == want and len(result) == 9, 'Source reverse identity and all nine COPY forms') + basis = {} + for row in result: + for pivot, value in sorted(basis.items()): + if row >> pivot & 1: + row ^= value + helpers = row >> (2*PORTS) + need(helpers != 0, 'Each relation has a new helper pivot') + pivot = 2*PORTS + (helpers & -helpers).bit_length()-1 + for old in list(basis): + if basis[old] >> pivot & 1: + basis[old] ^= row + basis[pivot] = row + need(len(basis) == 9, 'Nine independent helper relations') + pivots = sum(1 << i for i in basis) + for pivot, row in basis.items(): + need(row & pivots == 1 << pivot, 'Reduced helper basis') + need(all(word['final'][i] == 1 for i in range(SIZE) if row >> i & 1), + 'Every relation input has the full entrance frame') + return dict(sorted(basis.items())) + + +def construct(word, records, basis): + frames = list(word['final']) + [None] + rows = [1 << i for i in range(SIZE+1)] + program = [['CLEAR', SIZE, None]] + rows[SIZE] = 0 + for pivot, row in basis.items(): + program.append(['CLEAR', pivot, 1]) + rows[pivot] = 0 + for i in range(SIZE): + if i != pivot and row >> i & 1: + program.append(['ADD', pivot, i, 1]) + rows[pivot] ^= rows[i] + removed = [] + for index, (op, x, y, a, b, _) in enumerate(reversed(records)): + if op == 0: + old, new, rank = a, y, b + need(frames[x] == old, 'Source MOVE entrance') + if rows[x]: + program.append(['MOVE', x, old, new, rank]) + else: + program.append(['ZERO_MOVE', x, old, new]) + if rank: + removed.append([index, 'MOVE', x, rank]) + frames[x] = new + elif op == 1: + need(frames[x] == frames[y] == b, 'Source ADD frame') + if a & 1: + rows[x] ^= rows[y] + program.append(['ADD', x, y, b]) + elif op == 3: + need(y == SIZE and frames[x] == a and rows[x] == rows[SIZE] == 0, + 'All nine source COPY values are zero') + program.append(['CLEAR', SIZE, b]) + frames[SIZE] = b + removed.append([index, 'COPY', x, 7]) + else: + need(op == 2 and y == SIZE and rows[x] == rows[SIZE] == 0, + 'Zero COPY close') + program.append(['CLEAR', SIZE, None]) + frames[SIZE] = None + for pivot in basis: + program.append(['CLEAR', pivot, word['start'][pivot]]) + return program, removed + + +def replay(word, program, basis): + owned = set(basis) | {SIZE} + rows = [1 << i for i in range(SIZE+1)] + frames = list(word['final']) + [None] + paid = Counter() + largest_row = 1 + for event in program: + op, role = event[:2] + if op == 'CLEAR': + need(role in owned, 'Only an owned field can be cleared') + rows[role], frames[role] = 0, event[2] + elif op == 'ADD': + _, dst, src, frame = event + need(dst != src and frames[dst] == frames[src] == frame, 'Common-frame XOR') + rows[dst] ^= rows[src] + largest_row = max(largest_row, rows[dst].bit_count()) + elif op in ('MOVE', 'ZERO_MOVE'): + _, role, old, new, *rank = event + need(frames[role] == old, 'Native MOVE entrance') + if op == 'ZERO_MOVE': + need(rows[role] == 0, 'Only a zero value can change frame for free') + elif rank[0]: + paid[rank[0]] += 1 + frames[role] = new + else: + raise ValueError('Unknown local operation') + for i, row in enumerate(rows): + expected = 0 if i in owned else (1 << i) ^ ((1 << (i-PORTS)) if PORTS <= i < 2*PORTS else 0) + need(row == expected, 'Every retained and arbitrary owned entry column') + need(frames[:SIZE] == word['start'] and frames[SIZE] is None, 'All exit frames') + need(dict(paid) == NEW_PAID, 'Exact changed local paid profile') + return {'paid': dict(sorted(paid.items())), 'helpers': {8:439-len(basis)}, + 'retained_inputs': SIZE-len(basis), 'arbitrary_owned_entries': len(owned), + 'events': len(program), 'scalar_events': sum(e[0] in ('ADD', 'CLEAR') for e in program), + 'maximum_binary_row_weight': largest_row, + 'word_sha256': sha256(json.dumps(program, separators=(',', ':')).encode()).hexdigest()} + + +def native(word, records, frame_data): + load('research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py', 'joint_pair_dag') + module = load('research/kappa-rebuild/bit/mixed_productive_bit.py', 'bit_source_geometry') + projectors = module.frame_projectors(frame_data) + dims = {int(f): row['dim'] for f, row in frame_data.items()} + pairs = {(e[2], e[3], e[4]) for e in records if e[0] == 0} + for a, b, rank in pairs: + p, q = projectors[a], projectors[b] + need(module.matrix_multiply(p, q) == p == module.matrix_multiply(q, p), 'Nested exact projectors') + need(dims[b]-dims[a] == rank, 'Every original and reversed child rank') + multiply = module.matrix_multiply + def eye(n): + return [[Fraction(i == j) for j in range(n)] for i in range(n)] + def swap(p): + return [[Fraction(int(i == j)-(p[i][j] if i < 8 and j < 8 else p[i-8][j-8]) + if (i < 8) == (j < 8) else p[i][j-8] if i < 8 else p[i-8][j]) + for j in range(16)] for i in range(16)] + for port in range(PORTS): + p = projectors[word['start'][port]] + complement = [[Fraction(i == j)-p[i][j] for j in range(8)] for i in range(8)] + need(dims[word['start'][port]] == 1 and word['start'][port+PORTS] == 0, + 'Actual main entrance line and empty frame') + need(word['final'][port] == 1 and projectors[word['final'][port+PORTS]] == complement, + 'Actual main full frame and complement') + q = list(map(Fraction, word['lines'][port])) + need(sum(x*x for x in q) == 4 and p == [[x*y/4 for y in q] for x in q], + 'Source root and actual entrance projector') + u = [Fraction(i == 0)-q[i]/2 for i in range(8)] + norm = sum(x*x for x in u) + g = eye(8) if norm == 0 else [[Fraction(i == j)-2*u[i]*u[j]/norm for j in range(8)] for i in range(8)] + a = [row[1:] for row in g] + at = list(map(list, zip(*a))) + need(multiply(at,a) == eye(7) and multiply(a,at) == complement, 'Fresh exact complement basis') + rho = [p[i]+a[i] for i in range(8)] + [row+[Fraction(0)]*7 for row in at] + full = [[Fraction(i == j and i < 8) for j in range(15)] for i in range(15)] + active = [[p[i][j] if i < 8 and j < 8 else Fraction(i == j and i >= 8) for j in range(15)] for i in range(15)] + central = [[p[i][j] if i < 8 and j < 8 else Fraction(0) for j in range(15)] for i in range(15)] + need(multiply(rho,rho) == eye(15), 'Fresh port route is an involution') + need(multiply(multiply(rho,full),rho) == active, 'Every port route maps the full local projector to the next active block') + need(multiply(multiply(rho,central),rho) == central, 'Every route fixes the central query projector') + need(multiply(swap(eye(8)),swap(p)) == swap(complement), 'Exact address map D_I D_P equals D_K') + need(multiply(swap(p),swap(p)) == eye(16) and multiply(swap(complement),swap(complement)) == eye(16), + 'Both physical address factors are involutions') + need(all(word['start'][i] == 0 and word['final'][i] == 1 for i in range(2*PORTS, SIZE)), + 'Every retained helper has a rank-eight target') + return {'rational_projectors': len(projectors), 'nested_transition_pairs': len(pairs), + 'main_involution_ports': PORTS, 'fresh_port_routes': PORTS, 'new_nonzero_native_maps': 0, + 'all_f_rule': 'Source projectors tensor I_f; the source address involutions and all GF(2) identities stay exact.', + 'full_GL_cover_executed': False} + + +def controls(word, program, basis): + bad = json.loads(json.dumps(program)) + bad.pop(next(i for i, e in enumerate(bad) if e[0] == 'CLEAR' and e[1] in basis)) + variants = {'missing_owned_entry_clear': bad} + bad = json.loads(json.dumps(program)) + bad.pop(next(i for i, e in enumerate(bad) if e[0] == 'ADD' and e[1] in basis)) + variants['changed_relation'] = bad + bad = json.loads(json.dumps(program)) + bad.pop(max(i for i, e in enumerate(bad) if e[0] == 'CLEAR' and e[1] in basis)) + variants['missing_owned_exit_clear'] = bad + bad = json.loads(json.dumps(program)) + i = next(i for i, e in enumerate(bad) if e[0] == 'MOVE' and e[-1] > 0) + bad[i] = ['ZERO_MOVE'] + bad[i][1:4] + variants['unearned_free_transition'] = bad + failures = {} + for name, bad in variants.items(): + try: + replay(word, bad, basis) + except ValueError as error: + failures[name] = str(error) + else: + raise ValueError('Accepted local mutation: ' + name) + return failures + + +def run(): + word, records, frames = source() + basis = relations(word, records) + program, removed = construct(word, records, basis) + result = replay(word, program, basis) + need(Counter(e[-1] for e in removed) == {1:9, 7:9}, 'All removed jobs and no others') + result.update({'relation_basis': {str(p): [i for i in range(SIZE) if row >> i & 1] for p, row in basis.items()}, + 'removed': removed, 'native': native(word, records, frames), + 'negative_controls': controls(word, program, basis)}) + return result, program diff --git a/research/bit-nine-owned-relations/price.py b/research/bit-nine-owned-relations/price.py new file mode 100644 index 0000000000..7257ce9112 --- /dev/null +++ b/research/bit-nine-owned-relations/price.py @@ -0,0 +1,232 @@ +"""Price the complete BIT controller, cover and compiler. + +The controller and tail proof follow Cinna Davis, zxv and the retained +mixed-target work of Jacob Alan Sussman. Apache-2.0. +Ali Romman with substantial OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path +import json +import local as L + +TESTED, UNIFORM = Q('.0034678'), Q('.0034668') +AFTER, ATOM, OLD_ORDINARY = Q('.0034578'), Q('.004'), Q('.0000384599') +ADMITTED = Q('.00344412') + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k):encode(v) for k,v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def controller(word): + n = 2*word['pairs'] + L.need((word['kind'], n, word['prefix_pairs']) == ('bit', 32, 7), 'Source BIT p16/a7 controller') + def xor(dst, src): + for term, mask in src.items(): + value = dst.get(term, 0) ^ mask + if value: + dst[term] = value + else: + dst.pop(term, None) + def shifted(row, monomial): + return {term ^ monomial: mask for term, mask in row.items()} + def boundary(program): + rows = [1 << i for i in range(n)] + for event in program: + op, a, b = event + if op == 'ADD': + rows[a] ^= rows[b] + else: + L.need(op == 'SWAP', 'Binary boundary operation') + rows[a], rows[b] = rows[b], rows[a] + return rows + for side in ('left', 'right'): + L.need(boundary(word['boundaries'][side+'_program']) == word['boundaries'][side+'_rows'], + 'Every binary boundary coefficient') + rows = [{0:mask} for mask in word['boundaries']['right_rows']] + for event in word['physical_events']: + op = event[0] + if op in ('LOCAL', 'QUERY_SHEAR'): + _, stage, pair, reverse = event + x, y = 2*pair, 2*pair+1 + if reverse: + x, y = y, x + xor(rows[y], shifted(rows[x], 1)) + if op == 'LOCAL': + for role in (x, y): + rows[role] = shifted(rows[role], 1 << (stage+1)) + elif op == 'IDLE': + _, pair, stages = event + monomial = sum(1 << (stage+1) for stage in stages) + for role in (2*pair, 2*pair+1): + rows[role] = shifted(rows[role], monomial) + elif op == 'ADD': + xor(rows[event[1]], rows[event[2]]) + else: + L.need(op == 'SWAP', 'Physical controller operation') + rows[event[1]], rows[event[2]] = rows[event[2]], rows[event[1]] + result = [] + for mask in word['boundaries']['left_rows']: + row = {} + for i in range(n): + if mask >> i & 1: + xor(row, rows[i]) + result.append(row) + L.need(result == [{term:1 << i} for i,term in enumerate(word['diagonal'])], + 'Complete controller endpoint on all binary monomials') + return {'parent_inputs_per_port': n, 'physical_events': len(word['physical_events']), + 'full_calls': sum(e[0] == 'LOCAL' for e in word['physical_events']), + 'thin_calls': sum(e[0] == 'QUERY_SHEAR' for e in word['physical_events'])} + + +def invoice(word, paid, helpers): + targets, children = Counter(), Counter() + for event in word['physical_events']: + if event[0] == 'LOCAL': + targets.update(helpers) + children.update(paid) + elif event[0] == 'QUERY_SHEAR': + children[1] += L.PORTS + elif event[0] == 'IDLE': + children[7*len(event[2])] += 2*L.PORTS + for term in word['diagonal']: + L.need(term & 1, 'Every main target retains its central direction') + targets[1+7*(term >> 1).bit_count()] += L.PORTS + return targets, children + + +def tail(E, T, P, tested, uniform): + t, u, v, cutoff, floor = 1-tested, Q(1, 5), 1024, 17, 18 + target, paid = E.moment(T, t), E.moment(P, t) + alpha = E.divide(paid, target) + second = L.load('research/kappa-rebuild/architecture/mixed_target_probe.py', 'bit_relation_second_moments') + tl, th = second.moment(T, tested) + pl, ph = second.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 agree') + gamma = E.divide(E.moment(P, t+u), E.mul(E.power(cutoff, u), target)) + delta = E.divide((Q(sum(T.values())*floor),)*2, E.mul(E.power(cutoff, tested), target)) + reserve = Q(1, 250000) + L.need(alpha[1] < 1-reserve and gamma[1] < Q(31, 32) and delta[1] < Q(19, 20), + 'All three charged compiler ratios') + L.need(Q(31,32)**128 < Q(1,16) and Q(19,20)**128 < Q(1,16), 'Strict tail decay blocks') + surplus = 1-Q(1)/(1+v*reserve)-Q(4, 2**32) + L.need(surplus > 0 and cutoff**64 < floor**63 and max(T) < 256, + 'Completion, splitting and rounding surplus') + h = Q(1,64) + z, z0 = 1-uniform, (t+1-uniform)/2 + gap = z0-t + B, debt = (5+8*h)*v, 1+8*v*(1-z0) + x = (gap*B+debt)/(h*gap) + H0 = -((-x.numerator)//x.denominator) + x = H0*(1-z0)/(z-z0) + H1 = x.numerator//x.denominator+1 + L.need(H0 >= 8*v and H0*h*gap >= gap*B+debt and (H0-1)*h*gap < gap*B+debt, + 'Exact first compiler threshold') + L.need(H1*(z-z0) > H0*(1-z0) >= (H1-1)*(z-z0), 'Exact strict uniform threshold') + return {'tested': tested, 'uniform': uniform, 'alpha': E.display(alpha), + 'gamma': E.display(gamma), 'delta': E.display(delta), 'reserve': reserve, + 'tensor_power': v, 'cutoff': cutoff, 'floor': floor, + 'normalized_surplus_lower': surplus, 'H0': H0, 'H1': H1, + 'uniform_N': '2^'+str(H1), 'winning_word_materialized': False} + + +def root(E, T, P): + def margin(kappa): + a, b = E.moment(T, 1-kappa), E.moment(P, 1-kappa) + return a[0]-b[1], a[1]-b[0] + lo, hi, grid = 0, 10**10, 10**12 + while hi-lo > 1: + mid = (lo+hi)//2 + if margin(Q(mid,grid))[0] > 0: + lo = mid + else: + hi = mid + L.need(margin(Q(lo,grid))[0] > 0 > margin(Q(hi,grid))[1], 'Exact raw moment crossing') + return [Q(lo,grid), Q(hi,grid)] + + +def run(local): + word = json.loads((L.ROOT/'research/query-thinned-controllers/BIT-CONTROLLER.json').read_text()) + replay = controller(word) + L.need((replay['full_calls'], replay['thin_calls']) == (18,15), 'All full and thin calls counted') + T, P = invoice(word, local['paid'], local['helpers']) + oldT, oldP = invoice(word, L.OLD_PAID, {8:439}) + old_invoice = word['invoice'] + L.need(oldT == Counter({int(k):v for k,v in old_invoice['targets'].items()}) + and oldP == Counter({int(k):v for k,v in old_invoice['paid'].items()}), + 'Independent reconstruction of the complete predecessor invoice') + L.need(oldP-P == {1:162,7:162} and oldT-T == {8:162}, 'All eighteen local exchanges and target debits') + difference = {r:(P[r]-T[r])-(oldP[r]-oldT[r]) for r in set(P)|set(T)|set(oldP)|set(oldT)} + difference = {r:n for r,n in difference.items() if n} + concave = {k:sum(n*min(r,k) for r,n in difference.items()) for k in sorted(difference)} + L.need(all(v <= 0 for v in concave.values()) and min(concave.values()) < 0, + 'Exact uniform improvement for every strict concave rank power') + E = L.load('research/higher-moment-strictification/verify.py', 'bit_relation_exact_moments') + new_tail = tail(E, T, P, TESTED, UNIFORM) + old_tail = tail(E, oldT, oldP, Q('.00346'), Q('.003459')) + old_root, new_root = root(E, oldT, oldP), root(E, T, P) + L.need(new_root[0] > old_root[1] and TESTED < new_root[0], 'Changed raw ceiling and compiler headroom') + ordinary = (1-ATOM)*AFTER+ATOM*OLD_ORDINARY + old_ordinary = (1-ATOM)*Q('.00345')+ATOM*OLD_ORDINARY + L.need(UNIFORM-AFTER == Q('.003459')-Q('.00345') and 2**26 > 256/(UNIFORM-AFTER), + 'Same funded cover loss and finite prime rule') + L.need(ATOM > ordinary > ADMITTED > old_ordinary and ATOM < 1-ordinary, + 'Strict ordinary BIT admission and stock') + source_local_upper = 10**6 + source_scalar_events = 24305+2*9 + added_pointwise = local['scalar_events']-source_scalar_events + L.need(added_pointwise == 1568, 'All added pointwise XOR and CLEAR records') + local_bound = source_local_upper+added_pointwise + boundary = word['boundaries']['boundary_unit_ADDs_per_port'] + raw_bound = 18*local_bound+15*111*16+32*111*(len(word['physical_events'])+boundary) + L.need(raw_bound < 10**9, 'Retained source allowance plus every added record fits') + def complete_census(targets, children): + expected_targets, expected_paid = invoice(word, local['paid'], local['helpers']) + L.need(targets == expected_targets and children == expected_paid, 'Every paid job and earned target must match the literal word') + controls = {} + try: + complete_census(oldT, P) + except ValueError as error: + controls['missing_target_debit'] = str(error) + else: + raise ValueError('Accepted unearned helper targets') + a, b = E.moment(oldT,1-TESTED), E.moment(oldP,1-TESTED) + L.need(a[1] < b[0], 'The old complete bill fails at the new tested saving') + controls['old_word_at_new_saving'] = 'Rejected by the exact raw moment' + complex_receipt = json.loads((L.ROOT/'research/kappa-backward-controller-20261023/RESULT.json').read_text())['arithmetic'] + params = {k:Q(v) for k,v in complex_receipt['outer']['parameters'].items()} + params['bit_saving'] = ADMITTED + engine = L.load('research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'bit_relation_complete_outer') + outer = engine.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta']*(1-ATOM) + L.need(0 < params['beta']*(1-ATOM) < params['beta'] < 1, + 'The actual BIT row stock is sublinear in its active group') + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'All outer predicates are present') + L.need(all(v > 0 for group in ('strict_checks','functional_checks') for v in outer[group].values()), + 'The complete unchanged multiplication endpoint still passes') + L.need(params['kappa'] == Q('.00302728823'), 'No new multiplication kappa is claimed') + return encode({'controller': replay, 'targets': T, 'paid': P, + 'target_count': sum(T.values()), 'paid_count': sum(P.values()), + 'rank_credit': sum(r*n for r,n in T.items()), 'rank_bill': sum(r*n for r,n in P.items()), + 'signed_delta': difference, 'concave_order_certificate': concave, + 'old_raw_root': old_root, 'new_raw_root': new_root, + 'old_compiler': old_tail, 'new_compiler': new_tail, + 'ordinary_BIT': {'old_ordinary':old_ordinary, 'new_ordinary':ordinary, + 'gain_at_matched_parameters':ordinary-old_ordinary, + 'admitted':ADMITTED, 'atom':ATOM, 'after_cover':AFTER, + 'prime_rule':'Odd q > 2^26*N^5, avoiding all fixed denominators and rank witnesses'}, + 'budgets':{'inherited_source_local_upper':source_local_upper, + 'added_pointwise_records_per_call':added_pointwise, + 'local_scalar':local['scalar_events'], 'local_complete_upper':local_bound, + 'complete_raw_nonrecursive':raw_bound,'raw_allowance':10**9}, + 'negative_controls':controls, 'outer_at_unchanged_complex_endpoint':outer, + 'complete_multiplication_kappa_improvement':False, + 'binding_constraint':'The complex supplier remains below this BIT saving.'}) diff --git a/research/bit-nine-owned-relations/verify.py b/research/bit-nine-owned-relations/verify.py new file mode 100644 index 0000000000..19adda84c1 --- /dev/null +++ b/research/bit-nine-owned-relations/verify.py @@ -0,0 +1,92 @@ +"""Check the nine-relation BIT supplier and its complete conditional cost. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from hashlib import sha1, sha256 +from pathlib import Path +import gzip +import json +import sys + +sys.dont_write_bytecode = True +import local as L +import price as P + + +def authenticate(): + count = 0 + for row in json.loads((L.HERE/'SOURCES.json').read_text())['files']: + if row['usage'] != 'input': + continue + raw = (L.ROOT/row['path']).read_bytes() + L.need(sha256(raw).hexdigest() == row['sha256'], 'Changed source: '+row['path']) + L.need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == row['git_blob'], + 'Changed source Git object: '+row['path']) + count += 1 + return count + + +def columns(program, pivots): + owned = set(pivots) | {L.SIZE} + for column in range(L.SIZE+1): + state = bytearray(L.SIZE+1) + state[column] = 1 + for event in program: + op = event[0] + if op == 'CLEAR': + state[event[1]] = 0 + elif op == 'ADD': + state[event[1]] ^= state[event[2]] + elif op == 'ZERO_MOVE': + L.need(state[event[1]] == 0, 'Separate column replay: zero transport') + else: + L.need(op == 'MOVE', 'Separate column replay: known operation') + expected = bytearray(L.SIZE+1) + if column not in owned: + expected[column] = 1 + if column < L.PORTS: + expected[column+L.PORTS] = 1 + L.need(state == expected, 'Separate Boolean replay of every retained and owned column') + return {'columns': L.SIZE+1, 'method':'One Boolean input at a time; bytearray state; no symbolic row algebra'} + + +def run(): + pins = authenticate() + local, program = L.run() + column_check = columns(program, map(int, local['relation_basis'])) + price = P.run(local) + result = {'status':'PASS_BIT_NINE_OWNED_RELATIONS_00344412_NO_NEW_MULTIPLICATION_KAPPA', + 'source_inputs_authenticated':pins, 'local':local, 'separate_columns':column_check, + 'complete_cost':price, + 'limits':['The complex supplier still limits the complete multiplication bound.', + 'Native all-column, owned-erasure, compiler, precision/tape and analytic recovery premises remain conditional.', + 'The full GL cover, winning uniform word and complete integer multiplier are not materialized.', + 'No Lean or proof-kernel check is included.']} + artifact = {'schema':'bit-nine-owned-relations/1', 'source_word_sha256':L.sha256((L.SOURCE/'WORD.json.gz').read_bytes()).hexdigest(), + 'owned':sorted([int(p) for p in local['relation_basis']]+[L.SIZE]), + 'program':program} + return P.encode(result), artifact + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + result, artifact = run() + if args.write: + (L.HERE/'RESULT.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + (L.HERE/'WORD.json.gz').write_bytes(gzip.compress(json.dumps(artifact, separators=(',',':')).encode(), mtime=0)) + else: + L.need(json.loads((L.HERE/'RESULT.json').read_text()) == result, 'Frozen complete result') + L.need(json.loads(gzip.decompress((L.HERE/'WORD.json.gz').read_bytes())) == artifact, 'Frozen emitted word payload') + print(result['status']) + print(json.dumps({'retained_inputs':result['local']['retained_inputs'], + 'owned_entries':result['local']['arbitrary_owned_entries'], + 'paid_calls':result['complete_cost']['paid_count'], + 'productive_fields':result['complete_cost']['target_count'], + 'ordinary_BIT':result['complete_cost']['ordinary_BIT']}, sort_keys=True)) + + +if __name__ == '__main__': + main()