diff --git a/research/p104-a2-cleanup-composition/.gitattributes b/research/p104-a2-cleanup-composition/.gitattributes new file mode 100644 index 0000000000..8abeb4295b --- /dev/null +++ b/research/p104-a2-cleanup-composition/.gitattributes @@ -0,0 +1 @@ +inputs/** -text diff --git a/research/p104-a2-cleanup-composition/CONCURRENT-SOURCE.json b/research/p104-a2-cleanup-composition/CONCURRENT-SOURCE.json new file mode 100644 index 0000000000..74bc61b834 --- /dev/null +++ b/research/p104-a2-cleanup-composition/CONCURRENT-SOURCE.json @@ -0,0 +1,20 @@ +[ + { + "commit": "7916490124ac946704339a6a332bb76f06e5db5c", + "path": "research/p104-a2-neutral-cleanup/WORD.json.gz", + "local": "inputs/pr5650/WORD.json.gz", + "sha256": "e94809cecf9e9cba56dd7a8a11ff1edeedc4c34013ff6caebdaf3b021351cf8c" + }, + { + "commit": "7916490124ac946704339a6a332bb76f06e5db5c", + "path": "research/p104-a2-neutral-cleanup/FULL-RESULT.json", + "local": "inputs/pr5650/FULL-RESULT.json", + "sha256": "89c5b2bae30e73c626dfdfee3aebd1e8033d1f6d33688ba9d85ea502ef37c018" + }, + { + "commit": "7916490124ac946704339a6a332bb76f06e5db5c", + "path": "research/p104-a2-neutral-cleanup/NOTICE", + "local": "inputs/pr5650/NOTICE", + "sha256": "f7cdc54036e36f7b3409d988bcfea371627923bfca5f2fc2c6c7c8c1c7b65331" + } +] diff --git a/research/p104-a2-cleanup-composition/NOTICE b/research/p104-a2-cleanup-composition/NOTICE new file mode 100644 index 0000000000..72a14b3072 --- /dev/null +++ b/research/p104-a2-cleanup-composition/NOTICE @@ -0,0 +1,6 @@ +P104 A2 and helper-cleanup composition. +New composition and checks: Ali Romman with substantial OpenAI Codex assistance, 2026. +Apache-2.0. +The paid A2 witness is by zxv, with the PR3998/4019/4112/4152 lineage. +The helper cleanup and common PR5627 word are by Ali Romman with their retained source authors. +All source files and notices in inputs/ are retained unchanged. See README.md and SOURCE-CONTEXT.json. diff --git a/research/p104-a2-cleanup-composition/PRICING-EDITS.json b/research/p104-a2-cleanup-composition/PRICING-EDITS.json new file mode 100644 index 0000000000..d6ee1b301f --- /dev/null +++ b/research/p104-a2-cleanup-composition/PRICING-EDITS.json @@ -0,0 +1,18 @@ +[ + [ + "Q('.00310626335'), Q('.003106263355')", + "Q('.00310644469'), Q('.003106444692')" + ], + [ + "PREVIOUS = Q('.00310440546')", + "PREVIOUS = Q('.00310626335')" + ], + [ + "'kappa_decimal':'.00310626335'", + "'kappa_decimal':'.00310644469'" + ], + [ + "previous_open_pr5627", + "previous_open_pr5644" + ] +] diff --git a/research/p104-a2-cleanup-composition/README.md b/research/p104-a2-cleanup-composition/README.md new file mode 100644 index 0000000000..7d5ef17a08 --- /dev/null +++ b/research/p104-a2-cleanup-composition/README.md @@ -0,0 +1,162 @@ +# Corroborating replay of the concurrent P104 composition + +## Concurrent result and contribution status + +PR5650 was published while the final checks for this package were running. +The next upstream refresh found the overlap. The two emitted programs differ +only in their schema labels. Every instruction, frame, boundary, native map, +physical caller and complete invoice agrees exactly. The pinned comparison +is in CONCURRENT-SOURCE.json and compare.py. Both constructions were prepared +from PR5643/5644 before this cross-comparison. + +This package is retained as a separate construction/replay and exact artifact +comparison. It is not a new mechanism beyond PR5650. The 10^-11 difference in +the chosen claim is not counted as a research improvement. This concurrent +result is excluded from the donor's ten-result quota. Shared frozen check +engines are reused; this is not an independent implementation of every engine, +independent human scientific review or scientific admission of PR5650. + +The normal and optimized full replays and the Git-free full replay were +completed at bdf59f7af8049ef226e3c68ee730c2ac12d8a421. The reconciliation adds +only frozen comparison inputs, a comparison checker and explanatory prose. +The scientific constructor, verifier, pricing engine, emitted word and receipt +are unchanged. The comparison runs in normal and optimized mode and includes +a missing-event rejection control. The revised committed export is checked. + + +This construction supports conditional **kappa = 0.00310644469**. It composes +the paid A2 path of PR5643 with the three helper cleanups of PR5644 in one +literal word. The gain over PR5644 is **0.00000018134**. The raw crossing is +strictly between **0.00310644469581 and 0.00310644469582**. This is a complete +conditional construction under the retained five framework assumptions and +helper endpoint contract. It is not a selected-frontier update or independent +scientific acceptance. + +## Exact sources and overlap + +- PR5643, zxv: `a3ff5c628bfc8825553d62d913f3e91f75d6825f`. +- PR5644, Ali Romman: `c5871955d89bf73506fd68b0a5bf1cf2b3153c02`. +- Their common source PR5627: `ed4dc88a09a7d201971f6603b8c2074e95dd9c32`. +- Canonical main base: `df0137efd35e11b4445734bf612bdd4c7ebc330c`, priority 7, + selected conditional kappa 0.00310045. + +SOURCE-CONTEXT.json authenticates every retained source file before imports. +The PR5644 loader authenticates the complete common PR5627 export and each +of its payloads before use. Frozen files and notices stay unchanged. This +package reconstructs both published source words exactly. It then applies +the four published changes in both orders. Both orders produce the same +literal program, not only equal scalar endpoints. + +The live overlap check read the complete open PR/Discussion cache and the +current claims. New internal scalar identities, helper relations, MOVE +scheduling, paid histories, boundary gauges and input quotients remain +outside this scope. This is a four-change integration with a full new bill. +No scope held by another investigation is taken. + +## Composition proof + +The three PR5644 prefix identities restore helpers 291,321,369 to their +original independent input rows at their final charts. Each deletes only +later writes to that helper after its last read. The input preparation, +cut cancellation, dyadic scaling and exact prefix relation are retained. +They remove contacts on main roles 55,49,80, whose H1+H5 paths become H6. +No helper input is identified, erased or removed from the target invoice. +The complete proof and exact witnesses are frozen under inputs/pr5644. + +The PR5643 scalar pair uses A=715, B=388, C=340. Its old operations are +B -= 4A and C += B at chart 825. Its replacement is C -= 4A at 396, +C += B at 825, then B -= 4A at 127. Both give (A,B-4A,C+B-4A) on arbitrary +inputs. The actual nested chart chain is 598<396<825<127, of dimensions +1,3,6,9. Chart 598 has basis [491]. This changes A's two paid ranks from +5,3 to 2,6. The extra ordinary ADD is included in the complete cost. + +The constructor uses unique literal source gates and exact helper anchors. +In the reverse application order, the helper cut is relocated by its unique +anchor and the entire prefix row is checked again. It does not transfer an +old row identity merely by moving its index. All transports are reconstructed +from the scalar contacts, with strict public/owned nesting and source-frame +checks. The resulting two complete programs agree byte for byte after the +same deterministic transport reconstruction. All productive boundaries and +the chronological owned-instruction sequence agree with the common source. + +The combined local paid change from PR5627 is + +``` +-3 H1 + H2 - H3 -4 H5 +4 H6. +``` + +Every productive target is unchanged. The local paid profile is +`{1:2197,2:457,3:493,4:91,5:159,6:22,7:15}`. +The full caller executes the local word 18 times. It retains all 15 thin +query sites, all 3,120 idle jobs and all 12,958 productive targets. It pays +66,492 calls, with rank-mass surplus 760. The gain over PR5644 is the exact +moment change 18*(3^t+5^t-2^t-6^t)>0 for 0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "871499999999253/875000000000000", + "fixed_halo_explicit_metadata_branch": "67375000000001/875000000000", + "new_BIT_row_stock_sublinear_in_active_group": "3489499999997009/3500000000000000", + "new_semantic_group_guard": "3/3500000000000" + }, + "margins": { + "boundary_algebraic_matrix": "19026973733244563721791/6125000000000000000000000", + "fused_gaussian": "19026973733233691165373/6125000000000000000000000", + "global_coordinate_router": "10872556419/3500000000000", + "group_bit_router": "38053947469967382330743/12250000000000000000000000", + "group_scans": "1749999999999/1750000000000", + "main_transform": "19026973731494563721791/6125000000000000000000000", + "microbox_face_corrections": "67375000000001/875000000000", + "polynomial_products": "3499999999999/3500000000000", + "sparse_union_movement": "2507308223733244563721791/6125000000000000000000000" + }, + "parameters": { + "a": "10872556419/3500000000000", + "b": "543627821/175000000000", + "beta": "3499999999997/3500000000000", + "bit_saving": "17/5000", + "cap_xi": "5569808223731494563721791/6125000000000000000000000", + "complex_uniform_saving": "10872556421/3500000000000", + "d": "1/3500000000000", + "epsilon": "3499999999999/3500000000000", + "kappa": "310644469/100000000000", + "lambda_": "996893555309/1000000000000", + "lambda_prime": "1744563721791/1750000000000", + "layout": "1/3500000000000", + "q": "5436278209/1750000000000", + "r0": "1/35000000000000", + "stop": "1/3500000000000", + "tested_saving": "776611173/250000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "1027443581/3500000000000", + "actual_logarithmic_gamma_guard": "1/3500000000000", + "actual_logarithmic_group_guard": "555191776271130436278209/3062500000000000000000000", + "alpha_logarithm_absorption": "1/35000000000000", + "boundary_algebraic_matrix_above_kappa": "6994563721791/6125000000000000000000000", + "cap_above_band": "2507308223731494563721791/6125000000000000000000000", + "cap_below_cell": "555191776266755436278209/6125000000000000000000000", + "cap_below_phase_cell_power": "6680191776268505436278209/6125000000000000000000000", + "complex_above_effective": "1/3500000000000", + "complex_below_one_over_32": "4925122179/175000000000", + "complex_endpoint": "1/1750000000000", + "epsilon_below_one": "1/3500000000000", + "epsilon_positive": "3499999999999/3500000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "6983691165373/6125000000000000000000000", + "gaussian_above_main": "869563721791/3062500000000000000000000", + "global_coordinate_router_above_kappa": "1/875000000000", + "global_gamma_power_slack": "9/35000000000000", + "group_below_dimension": "1/1750000000000", + "group_bit_router_above_kappa": "17467382330743/12250000000000000000000000", + "group_gauge_power_slack": "555191776271042936278209/3062500000000000000000000", + "group_key_fits_record": "1/1750000000000", + "group_positive": "3499999999997/3500000000000", + "group_scans_above_kappa": "3489127443583/3500000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "687737135400418148631/500000000000000000000000", + "lambda_above_internal": "1/7000000000000", + "lambda_above_sigma": "3/7000000000000", + "lambda_above_tau": "1/7000000000000", + "lambda_prime_above_lambda": "1/7000000000000", + "lambda_prime_above_leaf": "349456372179/612500000000000000000000", + "leaf_saving_above_effective": "174456372179/612500000000000000000000", + "main_transform_above_kappa": "5244563721791/6125000000000000000000000", + "membership_arithmetic_fits_record": "1/3500000000000", + "microbox_face_corrections_above_kappa": "269489127443589/3500000000000", + "microbox_halo_volume": "276500000000003/3500000000000", + "new_complex_uniform_saving_above_b": "1/3500000000000", + "new_semantic_guard_with_C1_one": "1/3500000000000", + "polynomial_products_above_kappa": "27258808153/27343750000", + "positive_layout_slack": "1/3500000000000", + "q_below_effective": "1/3500000000000", + "q_below_internal": "1/3500000000000", + "q_below_leaf": "349456372179/612500000000000000000000", + "q_positive": "5436278209/1750000000000", + "short_record_fallback": "174456372179/175000000000", + "source_axis_superpolynomial": "1/3500000000000", + "sparse_union_movement_above_kappa": "2488281250006994563721791/6125000000000000000000000", + "stop_below_one": "3499999999999/3500000000000", + "stop_positive": "1/3500000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/3500000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/3500000000000", + "union_tag_work_per_visit_fits_record": "3/3500000000000" + } + }, + "paid": { + "1": 41106, + "16": 416, + "2": 8226, + "24": 416, + "3": 8874, + "32": 416, + "4": 1638, + "40": 416, + "48": 416, + "5": 2862, + "56": 416, + "6": 396, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66492, + "previous_open_pr5644": "62125267/20000000000", + "productive_fields": 12958, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-46262147594541099508843083517426769431530571502553738606261941/196159429230833773869868419475239575503198607639501078528", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "581/100000000000000", + "291/50000000000000" + ], + "raw_root_interval": [ + "310644469581/100000000000000", + "155322234791/50000000000000" + ], + "relative_gain_percent": "362680/62125267", + "strictification": { + "alpha": { + "lower": "0.999999999996119924430372081140", + "upper": "0.999999999996119924430372081141" + }, + "cutoff": 17, + "delta": { + "lower": "0.967531019709329098832769914879", + "upper": "0.967531019709329098832769914880" + }, + "floor": 18, + "gamma": { + "lower": "0.968151249906008931566993651877", + "upper": "0.968151249906008931566993651878" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "39/40", + "tail_offset": "1/5", + "tested": "776611173/250000000000" + }, + "targets": { + "1": 36, + "145": 208, + "17": 416, + "2": 72, + "25": 416, + "33": 416, + "4": 1638, + "41": 416, + "49": 416, + "5": 108, + "57": 416, + "65": 416, + "7": 90, + "73": 208, + "8": 288, + "9": 7398 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "extra_target": "Every productive helper has a native target", + "missing_A2_correction": "All public and owned rows", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "missing_helper_preparation": "All public and owned rows", + "missing_owned_clear": "All public and owned exits", + "unfunded_query": "Complete field and call counts" + }, + "local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2197, + "2": 457, + "3": 493, + "4": 91, + "5": 159, + "6": 22, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220220 + }, + "native": { + "distinct_maps": 2916, + "helper_normalizers": 1070, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "4b1cbe1539a57fa2fac54b3d4e7a509bc9fe6cada4ad9f7ce29814f71c4b6760", + "wrong_phase_rejected": true + }, + "physical": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 565504, + "columns": 752 + }, + "source_heads": { + "5643": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "5644": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02" + }, + "status": "PASS_P104_A2_CLEANUP_KAPPA_00310644469" +} diff --git a/research/p104-a2-cleanup-composition/SOURCE-CONTEXT.json b/research/p104-a2-cleanup-composition/SOURCE-CONTEXT.json new file mode 100644 index 0000000000..705827a202 --- /dev/null +++ b/research/p104-a2-cleanup-composition/SOURCE-CONTEXT.json @@ -0,0 +1,130 @@ +[ + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/README.md", + "local": "inputs/pr5644/README.md", + "size": 6530, + "sha256": "e7f7f83f70ab231067bcfeadb7a03ecbcb69a18cccff6cf7085ef38c1f46d04a" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/PROOF.md", + "local": "inputs/pr5644/PROOF.md", + "size": 6057, + "sha256": "a599da8788777e8d703665322641ce4be6e025bddf96d79b07c1b7977e72dd50" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/NOTICE", + "local": "inputs/pr5644/NOTICE", + "size": 296, + "sha256": "8ae3e07251d69074dddb5f94688f9d0ffd323214b4e48293c26c2d79b9acffe7" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/SOURCES.json", + "local": "inputs/pr5644/SOURCES.json", + "size": 1384, + "sha256": "bc32dcab5cc31a944c67cb25d59fe5c9822ec4cc397f6179f3349117cbdb9dc7" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/WITNESS.json", + "local": "inputs/pr5644/WITNESS.json", + "size": 1124, + "sha256": "0cf78fcbdb62bd4965536dd7d2f74f96761fcd95b11d750bc68ac81ceb1ec58c" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/WORD.json.gz", + "local": "inputs/pr5644/WORD.json.gz", + "size": 107894, + "sha256": "3f2563d3c98f9d1170a583ba78bf171d5eb24e21976ddb026216bc637fc8a2ad" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/RESULT.json", + "local": "inputs/pr5644/RESULT.json", + "size": 16949, + "sha256": "b4252113207b900c8b853450ba6fdd5c030e563698dd1d90b04f79195ee96699" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/construct.py", + "local": "inputs/pr5644/construct.py", + "size": 5361, + "sha256": "99ff4814b7c106973b149d1d4342c7e4608a027445bf07b19b5364658970099e" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/sources.py", + "local": "inputs/pr5644/sources.py", + "size": 2617, + "sha256": "add4c3a2567a11f36c88bbdd1c4f551044b68141e3faf7053da71b39972e8f41" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/pricing.py", + "local": "inputs/pr5644/pricing.py", + "size": 10149, + "sha256": "1ceef843721af011c3af32b95e20486c3f53ef937489d559bec721c250499801" + }, + { + "pr": 5644, + "commit": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02", + "path": "research/p104-neutral-helper-cleanup/inputs/pr5627-source.tar", + "local": "inputs/pr5644/inputs/pr5627-source.tar", + "size": 1648640, + "sha256": "86c6bb839e14d79175ff8f3ed80b51a02d5c51a04deb0eff7ccea1afbe72923b" + }, + { + "pr": 5643, + "commit": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "path": "research/p104-a2-paid-rank-exchange/README.md", + "local": "inputs/pr5643/README.md", + "size": 8494, + "sha256": "619a4260fc29c8163b48eb857e0c9d8f159bdf7964f60fb4d864d52748ec778d" + }, + { + "pr": 5643, + "commit": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "path": "research/p104-a2-paid-rank-exchange/INDEPENDENT-AUDIT.md", + "local": "inputs/pr5643/INDEPENDENT-AUDIT.md", + "size": 3888, + "sha256": "7f1395e8610a5ab338c22356fd4c5cc367f6119a6831a3088c807c11c50bf1fe" + }, + { + "pr": 5643, + "commit": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "path": "research/p104-a2-paid-rank-exchange/construct.py", + "local": "inputs/pr5643/construct.py", + "size": 3792, + "sha256": "72ec32be21cf1bdb22bd68532947b2cf59625c8150c824ab958c0802aac97218" + }, + { + "pr": 5643, + "commit": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "path": "research/p104-a2-paid-rank-exchange/WORD.json.gz", + "local": "inputs/pr5643/WORD.json.gz", + "size": 106609, + "sha256": "b2ab778bdd5d68c62df0b51c12dc33fde93ad89213639a8e7da23e4b9cf6c3dc" + }, + { + "pr": 5643, + "commit": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "path": "research/p104-a2-paid-rank-exchange/RESULT.json", + "local": "inputs/pr5643/RESULT.json", + "size": 11753, + "sha256": "aed4423525ee826700104a2b48b30cade77d304db351b13d85f7b6fd96fb8922" + } +] diff --git a/research/p104-a2-cleanup-composition/SOURCES.json b/research/p104-a2-cleanup-composition/SOURCES.json new file mode 100644 index 0000000000..2d7c75517f --- /dev/null +++ b/research/p104-a2-cleanup-composition/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ] +} diff --git a/research/p104-a2-cleanup-composition/TASK.json b/research/p104-a2-cleanup-composition/TASK.json new file mode 100644 index 0000000000..305f2617b2 --- /dev/null +++ b/research/p104-a2-cleanup-composition/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Corroborate the concurrent PR5650 P104 composition with a separately constructed full replay and exact word/invoice comparison.", + "scope_change_reason": "A refreshed overlap check found PR5650 after both proposals were published. The exact programs agree. Reclassify as corroboration and exclude this overlap from the ten-result quota.", + "bottleneck_link": "The composition preserves all target credit and makes a further strict reduction in the complete paid Gaussian moment.", + "budget_minutes": 120, + "stop_rule": "Stop after the exact four-change composition, both-order identity, all-column/native/caller and complete cost checks. Do not search new motifs or take active scopes.", + "outcome": "completed", + "evidence": "WORD.json.gz, RESULT.json, construct.py and verify.py; conditional kappa .00310644469 under source assumptions. CONCURRENT-SOURCE.json and compare.py establish exact equivalence with PR5650; no distinct mechanism is claimed.", + "author": "Ali Romman with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for construction, verification, prose and publication. No subagents or independent human review.", + "open_questions": [ + { + "question": "Does independent scientific review accept the exact common word and complete bound?", + "why_it_matters": "Author checks are not scientific admission or a selected-frontier update.", + "first_step": "Inspect both literal application orders and replay the complete verifier.", + "blocked_by": "No technical blocker; the five framework assumptions and helper endpoint contract remain." + } + ] +} diff --git a/research/p104-a2-cleanup-composition/VERIFY.json b/research/p104-a2-cleanup-composition/VERIFY.json new file mode 100644 index 0000000000..24db2ec663 --- /dev/null +++ b/research/p104-a2-cleanup-composition/VERIFY.json @@ -0,0 +1,55 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 570, + "checks": "Both composition orders, both exact source words, all columns/native phases, full caller, two rational moments, complete compiler/outer costs and corruption controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 570, + "checks": "Both composition orders, both exact source words, all columns/native phases, full caller, two rational moments, complete compiler/outer costs and corruption controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/compare.py" + ], + "timeout_seconds": 20, + "checks": "Authenticate PR5650 and compare the entire program, native maps, caller and invoice; reject a missing event." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/compare.py" + ], + "timeout_seconds": 20, + "checks": "Authenticate PR5650 and compare the entire program, native maps, caller and invoice; reject a missing event." + } + ] +} diff --git a/research/p104-a2-cleanup-composition/WORD.json.gz b/research/p104-a2-cleanup-composition/WORD.json.gz new file mode 100644 index 0000000000..c4338a6153 Binary files /dev/null and b/research/p104-a2-cleanup-composition/WORD.json.gz differ diff --git a/research/p104-a2-cleanup-composition/compare.py b/research/p104-a2-cleanup-composition/compare.py new file mode 100644 index 0000000000..6bf7bf1f61 --- /dev/null +++ b/research/p104-a2-cleanup-composition/compare.py @@ -0,0 +1,55 @@ +"""Compare the concurrent P104 artifacts. Ali Romman with OpenAI Codex. Apache-2.0.""" +from copy import deepcopy +from hashlib import sha256 +import gzip +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def compare_word(a, b): + need(a.keys() == b.keys(), 'Same complete word fields') + need({k for k in a if a[k] != b[k]} == {'schema'}, 'Only the schema label differs') + return sha256(json.dumps({k:v for k,v in a.items() if k != 'schema'},sort_keys=True,separators=(',',':')).encode()).hexdigest() + + +def main(): + pins = read(HERE/'CONCURRENT-SOURCE.json') + for row in pins: + need(sha256((HERE/row['local']).read_bytes()).hexdigest() == row['sha256'], 'Exact concurrent source pin') + a,b = read(HERE/'WORD.json.gz'),read(HERE/'inputs/pr5650/WORD.json.gz') + digest = compare_word(a,b) + mutant = deepcopy(b) + mutant['program'].pop() + try: + compare_word(a,mutant) + except ValueError: + pass + else: + raise ValueError('Missing-event control accepted') + a,b = read(HERE/'RESULT.json'),read(HERE/'inputs/pr5650/FULL-RESULT.json') + for key in ['local','native','physical']: + need(a[key] == b[key], 'Same full scientific result: '+key) + need(a['separate_columns'] == b['transpose'], 'Same complete dense-column result') + shared = ['paid','targets','productive_fields','paid_calls','rank_mass_surplus','raw_root_interval', + 'raw_ceiling','nonrecursive','ordinary_BIT','full_forward_calls','query_shears','whole_idle_jobs'] + for key in shared: + need(a['complete_cost'][key] == b['complete_cost'][key], 'Same invoice property: '+key) + print('PASS_CONCURRENT_P104_SAME_WORD_AND_INVOICE') + print('shared_word_sha256='+digest) + print('The two claim/test points differ. They do not define different mechanisms.') + + +if __name__ == '__main__': + main() diff --git a/research/p104-a2-cleanup-composition/construct.py b/research/p104-a2-cleanup-composition/construct.py new file mode 100644 index 0000000000..403b046d46 --- /dev/null +++ b/research/p104-a2-cleanup-composition/construct.py @@ -0,0 +1,94 @@ +"""Compose the published P104 changes. Ali Romman with OpenAI Codex. Apache-2.0. + +The paid A2 witness and frame reconstruction are from zxv PR5643. +The helper relations and coalescing are from Ali Romman PR5644. +""" +from collections import Counter +from copy import deepcopy + + +def rethread(word, L): + """Rebuild every typed transport from the scalar contact sequence.""" + current = word['initial'] + [None]*word['owned_fields'] + spans = [L.span(b) for b in word['frames']] + active, program = set(), [] + + def move(role, frame): + old = current[role] + if old == frame: + return + private = role in active + L.need(old is not None and (spans[frame] < spans[old] if private else spans[old] < spans[frame]), + 'Strict nested transport at every contact') + program.append(['MOVE', role, old, frame, private]) + current[role] = frame + + for event in word['program']: + if event[0] == 'MOVE': + continue + op, role = event[:2] + if op == 'INIT': + L.need(current[role] is None, 'Fresh owned slot') + active.add(role) + current[role] = event[2] + elif op == 'CLEAR': + move(role, event[2]) + active.remove(role) + current[role] = None + else: + move(role, event[-1]) + if op != 'SCALE': + move(event[2], event[-1]) + program.append(event[:]) + for role in range(word['public']): + move(role, word['final'][role]) + out = deepcopy(word) + out['program'] = program + return out + + +def a2(word, L): + first = ['ADD',388,715,'-4',825] + second = ['ADD',340,388,'1',825] + scalar = [e[:] for e in word['program'] if e[0] != 'MOVE'] + L.need(scalar.count(first) == scalar.count(second) == 1, 'Unique published A2 anchors') + at = scalar.index(first) + L.need(scalar[at+1] == second, 'Consecutive scalar A2 gates') + L.need([word['frames'][f] for f in [598,396,825,127]] == + [[491],[13,70,416],[7,10,32,65,144,272],[1,2,4,8,16,32,64,128,256]], 'Published A2 chart chain') + scalar[at:at+2] = [['ADD',340,715,'-4',396],second,['ADD',388,715,'-4',127]] + out = deepcopy(word) + out['program'] = scalar + return rethread(out, L) + + +def delta(old, new, key): + c = Counter(new[key]) + c.subtract(old[key]) + return {r:n for r,n in c.items() if n} + + +def compose(source, witness, cleanup, L): + before = L.replay(source) + neutral, changes, neutral_local = cleanup.construct(source, witness, L) + combined = a2(neutral, L) + after = L.replay(combined) + L.need(delta(neutral_local,after,'paid') == {2:1,3:-1,5:-1,6:1}, 'Published A2 paid change survives cleanup') + L.need(delta(before,after,'paid') == {1:-3,2:1,3:-1,5:-4,6:4}, 'Exact composed paid change') + L.need(before['helpers'] == after['helpers'], 'All target ranks retained') + L.need(cleanup.owned_events(source) == cleanup.owned_events(combined), 'All owned operations retained in order') + # Rebuild in the other order. Cuts use exact anchors and recheck full rows. + other = a2(source, L) + alternate = [] + for old in witness: + w = deepcopy(old) + matches = [i for i,e in enumerate(other['program']) if e == w['anchor']] + L.need(len(matches) == 1, 'Unique helper anchor after the A2 change') + w['cut'] = matches[0] + other, receipt = cleanup.relation(other, w, L) + alternate.append(receipt) + other = rethread(other, L) + L.need(other['program'] == combined['program'], 'Both composition orders give the same literal word') + L.need(L.replay(other) == after, 'Second composition endpoint') + combined['schema'] = 'p104-a2-cleanup-composition/1' + return combined, {'cleanup_then_A2':changes, 'A2_then_cleanup':alternate}, after, neutral, before diff --git a/research/p104-a2-cleanup-composition/inputs/pr5643/INDEPENDENT-AUDIT.md b/research/p104-a2-cleanup-composition/inputs/pr5643/INDEPENDENT-AUDIT.md new file mode 100644 index 0000000000..f690208abf --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5643/INDEPENDENT-AUDIT.md @@ -0,0 +1,74 @@ +# Independent scoped audit of the P104 A2 exchange + +Prepared for zxv with substantial OpenAI Codex assistance; Apache-2.0. +The transport sidequest supplied the construction. Ali Romman's PR5627 and the +credited P104 scalar/native/helper/controller/compiler lineage remain the source. +The elementary three-shear identity is not claimed as a new general theorem. + +The exact source is PR5627 commit +`ed4dc88a09a7d201971f6603b8c2074e95dd9c32`. The candidate byte hash is recorded +in `INDEPENDENT-AUDIT.json` and was read independently from the proposed word. + +## Exact scalar identity + +Write A=register715, B=register388, C=register340. The old adjacent scalar gates +are B←B−4A, C←C+B, so the final triple is (A,B−4A,C+B−4A). The proposed triple +C←C−4A, C←C+B, B←B−4A has the same final values for every input. The audit checks +all three basis columns over exact rationals. Omitting the direct or final shear, +or flipping the direct coefficient's sign, is rejected. + +After deleting MOVE instructions, the candidate's entire scalar program is exactly +the source program with this two-to-three replacement. All other scalar gates +and their order are unchanged. In particular, all COPY, INIT and CLEAR instructions +and their complete sequence are unchanged. Every initial/final frame, main port, +public/owned inventory and frame table is unchanged. + +## Why different scalar charts do not create a hidden operator assumption + +For every legal chart f, let Φ_f be the actual native chart operator, with its +full phase. Use z_r for a register's value in the common reference coordinates. +The physical field in chart f is Φ_f z_r. At a coframed scalar gate, + + Φ_f z_r + q Φ_f z_s = Φ_f (z_r+q z_s). + +At a paid change a→b, the supplied native map is Φ_b Φ_a⁻¹, so it sends +Φ_a z_r to Φ_b z_r. These two exact identities prove the frame invariant by +induction through the chronological program. The proof never commutes physical +Gaussians through one another, discards a phase, or identifies tensors of sums +with sums of tensors. Owned operations retain their existing checked contracts. + +The root's fresh native replay checks the actual new maps and full phases; +its physical caller and exact price replay are separate evidence. Under those +passed checks and the retained all-column native hypothesis, the invariant +applies at every lifted width. Since both programs have the same scalar endpoint +map and the same endpoint charts, they have the same physical endpoint map. +There is no additional native alphabet, input source, owned-zero rule, address +projection, or normalization assumption in this edit. + +## Exact paid change + +The altered source715 itinerary goes through the strict nested chart chain +598⊂396⊂825⊂127, whose dimensions are1,3,6,9. Previously its contacts required +rank5 then rank3; now they require rank2 then rank6. The independent complete-word +histogram check gives exactly + + Δpaid = H2 + H6 − H3 − H5. + +Every productive target is retained. The rank mass is unchanged:2+6=3+5=8. +For 0 6^t−5^t, + +hence H2+H6 6^t−5^t`. Thus the paid moment falls strictly, although one ADD is +added and rank mass is unchanged. The complete caller invokes the local word +18 times, so its paid change is 18 times this expression. The correction's +ordinary cost is included in the revised allowance shown above. + +This changes the local debt in zxv's +[PR5554 price-frontier theorem](https://github.com/CrocSwap/integer-mult-bounds/pull/5554). +It does not contradict that theorem's fixed-provider ceiling. Earlier A2 +contractions in PR3998/4019 and their PR4112/4152 audits retained their paid +profiles; those frozen-word exclusions are not claims about this changed P104 +word and itinerary. The elementary A2 identity itself is credited prior work. + +[INDEPENDENT-AUDIT.md](INDEPENDENT-AUDIT.md) gives the separate agent's +three-column proof and all-column frame-induction argument. Actual native +maps include their full phases. The argument does not commute Gaussians or +treat tensor powers of sums as sums of tensor powers. + +## Verification + +Python 3.12 and the standard library suffice. From the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/p104-a2-paid-rank-exchange +``` + +For a standalone exported directory, run `python3.12 -I -O -B verify.py` from +any working directory. `--quick` checks the exact source, regenerated word and +full rational scalar/frame interface without the native replay. `audit.py` +independently checks the scalar identity, entire scalar-program delta, +unchanged boundaries/owned instructions, nesting and complete paid histogram. + +The full verifier checks all 752 arbitrary-input rows and dense transpose +columns; 2,916 distinct signed native maps with exact global phases; the full +physical caller; both exact rational moment engines; compiler completion, +precision/ordinary allowances and BIT stock; all 54 strict and four functional +outer predicates. Controls reject an omitted new shear, wrong contact frame, +undercharged child and missing central translation. + +`RESULT.json` and `REPLAY.log` retain the complete successful source-bound +calculation. `PRICING-EDITS.json` binds the price adaptation to three literal +claim/comparison edits; no mathematical predicate is weakened. The historical +`previous_open_pr5601` output-key spelling is inherited; its value in this +package is the explicitly declared PR5627 comparison, 0.00310440546. + +The historical hosted nine-stage packing cap does not apply to this mixed-target +productive-helper construction: independent helper targets and the complete +caller replace that coverage law. The replacement bound is the unique complete- +invoice raw crossing above, proved on [0, 0.0034]. The claimed κ realizes about +99.9997879% of that fixed-invoice ceiling; this is not a ceiling on changed words. + +## Sources, scope and attribution + +The exact scientific predecessor is +[PR5627](https://github.com/CrocSwap/integer-mult-bounds/pull/5627), head +`ed4dc88a09a7d201971f6603b8c2074e95dd9c32`. Its word, checker, invoice and +source manifest are retained unchanged. The PR5612 authenticated archive +reader supplies the unchanged framework closure. All 12 PR5627-declared +foundation files present in that closure match its recorded SHA256 values +before use. `SOURCES.json` additionally authenticates every retained input +byte. There is no foreign-branch object-cache dependency. + +During the original research session, canonical Git fetch failed because +that checkout's `.git/FETCH_HEAD` was +protected. Exact source files were instead downloaded from their pinned +GitHub pages. Local task provenance remains main `f626db5c`, priority 7; it is +not represented as a refreshed canonical checkout. The live open-PR list was +checked through PR5635, including PR5633's narrower source-interface/invoice +audit. The older broad overlap cache has incomplete freshness, and no absence +of matches is asserted as proof of novelty. The submission-time browser check +subsequently synchronized the publication fork to canonical main +`09062e91a942f205a529779b74c13c412afdb483`, read current `autoresearch.md`, +priorities (still revision 7) and `CONTRIBUTING.md`, and checked the live PR +list through PR5639. PR5639 explicitly does not claim a new best whole +multiplication κ. The scientific source pins and earlier replay evidence +above remain frozen; shell Git refresh and committed-byte publication +preflight remain unavailable. No source frontier, frozen package +or others' PR was changed. The later publication checkout resolves the Git +refresh and committed-byte limitations; see [PUBLICATION.md](PUBLICATION.md) +for the fresh replay, source-history scope and overlap coverage. Historical +`CLAIM.json`, `TASK.json`, `VALIDATION.json` and their logs retain the original +session's status and limitations. Publication/CI/maintainer acceptance remain +separate. + +The same five framework assumptions remain: native all-column realization, +owned erasure, uniform compiler closure, precision/fixed-tape execution and +analytic recovery, together with the inherited helper-endpoint contract. +The enormous uniform word and complete rounded multiplier are not materialized. + +Prepared for **zxv**, with substantial OpenAI Codex assistance and complementary +subagent searches. Ali Romman supplies the PR5627 helper/basis composition and +checker; flyingviper supplies the relays; Scratch-net the prepared prefix; +Pierre-Loic Doulcet/hexapode the commuting cascade; Joel Pulikkan/GamingPuzzled, +DreamingOfClouds and thu-nmrc the predecessor handoffs and contacts. Retain +David Arias, Gareth Davidson, Cinna Davis, Jacob Alan Sussman, Cao Yifan, zxv +and all native, geometry, BIT, compiler and analytic source notices. Chris R / +Clear1nsight's PR3998, ToikY's PR4019 and the scoped audits retain credit for +the A2 mechanism and boundary discipline. Apache-2.0. + +## Open next questions + +1. Independently review the three literal gates, source chart chain and new + paid maps before scientific admission; use the isolated replay above. +2. Test a different noncommuting scalar motif on the emitted word. A combined + gain needs a reconstructed common word and complete invoice; local headline + gains are not assumed additive. No further positive candidate is claimed. diff --git a/research/p104-a2-cleanup-composition/inputs/pr5643/RESULT.json b/research/p104-a2-cleanup-composition/inputs/pr5643/RESULT.json new file mode 100644 index 0000000000..b20672f0a1 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5643/RESULT.json @@ -0,0 +1,342 @@ +{ + "complete_cost": { + "compiler": { + "H": 707182000000000, + "N": "2^707182000000000", + "eta": { + "lower": "0.000000134111266725226492278714", + "upper": "0.000000134111266725226492278715" + }, + "gap": "1/14000000000", + "integer_test_exponent": 50513, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "21732063/7000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "8727/50000000000", + "kappa": "155229/50000000", + "kappa_decimal": ".00310458", + "margin_at_previous": { + "lower": "0.044045194632554451118597166502", + "upper": "0.044045194632554451118597166503" + }, + "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_paid_rank_mass": 5986, + "local_routes": 5175000, + "local_scalar": 220166, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "ordinary_BIT": { + "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": "608497735956535877/196000000000000000000", + "fused_gaussian": "608497735869607631/196000000000000000000", + "global_coordinate_router": "10866031/3500000000", + "group_bit_router": "152124437467401907/49000000000000000000", + "group_scans": "6999999999/7000000000", + "main_transform": "608497721956535877/196000000000000000000", + "microbox_face_corrections": "269500000001/3500000000", + "polynomial_products": "13999999999/14000000000", + "sparse_union_movement": "80233497735956535877/196000000000000000000" + }, + "parameters": { + "a": "10866031/3500000000", + "b": "347713/112000000", + "beta": "13999999997/14000000000", + "bit_saving": "17/5000", + "cap_xi": "178233497721956535877/196000000000000000000", + "complex_uniform_saving": "21732063/7000000000", + "d": "1/14000000000", + "epsilon": "13999999999/14000000000", + "kappa": "155229/50000000", + "lambda_": "3987581679/4000000000", + "lambda_prime": "13956535877/14000000000", + "layout": "1/14000000000", + "q": "43464123/14000000000", + "r0": "1/140000000000", + "stop": "1/14000000000", + "tested_saving": "6209161/2000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "1033969/3500000000", + "actual_logarithmic_gamma_guard": "1/14000000000", + "actual_logarithmic_group_guard": "17766502299043464123/98000000000000000000", + "alpha_logarithm_absorption": "1/140000000000", + "boundary_algebraic_matrix_above_kappa": "55956535877/196000000000000000000", + "cap_above_band": "80233497721956535877/196000000000000000000", + "cap_below_cell": "17766502264043464123/196000000000000000000", + "cap_below_phase_cell_power": "213766502278043464123/196000000000000000000", + "complex_above_effective": "1/14000000000", + "complex_below_one_over_32": "3152287/112000000", + "complex_endpoint": "1/7000000000", + "epsilon_below_one": "1/14000000000", + "epsilon_positive": "13999999999/14000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "55869607631/196000000000000000000", + "gaussian_above_main": "6956535877/98000000000000000000", + "global_coordinate_router_above_kappa": "1/3500000000", + "global_gamma_power_slack": "9/140000000000", + "group_below_dimension": "1/7000000000", + "group_bit_router_above_kappa": "17467401907/49000000000000000000", + "group_gauge_power_slack": "17766502298343464123/98000000000000000000", + "group_key_fits_record": "1/7000000000", + "group_positive": "13999999997/14000000000", + "group_scans_above_kappa": "6978267939/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "686804790400418148631/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": "223652287/1568000000000000000", + "leaf_saving_above_effective": "111652287/1568000000000000000", + "main_transform_above_kappa": "41956535877/196000000000000000000", + "membership_arithmetic_fits_record": "1/14000000000", + "microbox_face_corrections_above_kappa": "269489133971/3500000000", + "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": "13956535879/14000000000", + "positive_layout_slack": "1/14000000000", + "q_below_effective": "1/14000000000", + "q_below_internal": "1/14000000000", + "q_below_leaf": "223652287/1568000000000000000", + "q_positive": "43464123/14000000000", + "short_record_fallback": "111652287/112000000", + "source_axis_superpolynomial": "1/14000000000", + "sparse_union_movement_above_kappa": "79625000055956535877/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": 41160, + "16": 416, + "2": 8226, + "24": 416, + "3": 8874, + "32": 416, + "4": 1638, + "40": 416, + "48": 416, + "5": 2916, + "56": 416, + "6": 342, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66546, + "previous_open_pr5601": "155220273/50000000000", + "productive_fields": 12958, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-740652532917121353648727598109847061213602736923586290417876337/3138550867693340381917894711603833208051177722232017256448", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "164639/25000000000000", + "658557/100000000000000" + ], + "raw_root_interval": [ + "77614664639/25000000000000", + "310458658557/100000000000000" + ], + "relative_gain_percent": "290900/51740091", + "strictification": { + "alpha": { + "lower": "0.999999993807112591662250764905", + "upper": "0.999999993807112591662250764906" + }, + "cutoff": 17, + "delta": { + "lower": "0.967529933442697782667099686380", + "upper": "0.967529933442697782667099686381" + }, + "floor": 18, + "gamma": { + "lower": "0.968063886259541319614126023064", + "upper": "0.968063886259541319614126023065" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "39/40", + "tail_offset": "1/5", + "tested": "6209161/2000000000" + }, + "targets": { + "1": 36, + "145": 208, + "17": 416, + "2": 72, + "25": 416, + "33": 416, + "4": 1638, + "41": 416, + "49": 416, + "5": 108, + "57": 416, + "65": 416, + "7": 90, + "73": 208, + "8": 288, + "9": 7398 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "missing_A2_correction": "All public and owned rows", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "undercharged_child": "Complete rank surplus", + "wrong_new_contact_frame": "Scalar destination and coefficient" + }, + "local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2200, + "2": 457, + "3": 493, + "4": 91, + "5": 162, + "6": 19, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220166 + }, + "native": { + "distinct_maps": 2916, + "helper_normalizers": 1070, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "e2b50e4067abb6ce5255be46754c1a3996d179cd95f949a86249762539138ef3", + "wrong_phase_rejected": true + }, + "physical": { + "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 + ] + }, + "source_foundation_matches": [ + "research/p104-productive-controller/caller.py", + "research/p104-productive-controller/CONTROLLER.json", + "research/joint-helper-lattice/CONTROLLER.json", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/higher-moment-strictification/verify.py", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/query-thinned-controllers/RESULT.json", + "research/p104-productive-controller/local.py" + ], + "source_head": "ed4dc88a09a7d201971f6603b8c2074e95dd9c32", + "source_pr": 5627, + "status": "PASS_P104_A2_KAPPA_00310458", + "transpose": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 565504, + "columns": 752 + }, + "wall_seconds": "156.498" +} diff --git a/research/p104-a2-cleanup-composition/inputs/pr5643/WORD.json.gz b/research/p104-a2-cleanup-composition/inputs/pr5643/WORD.json.gz new file mode 100644 index 0000000000..7cf851189d Binary files /dev/null and b/research/p104-a2-cleanup-composition/inputs/pr5643/WORD.json.gz differ diff --git a/research/p104-a2-cleanup-composition/inputs/pr5643/construct.py b/research/p104-a2-cleanup-composition/inputs/pr5643/construct.py new file mode 100644 index 0000000000..9500a34a53 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5643/construct.py @@ -0,0 +1,64 @@ +"""Construct a complete P104 A2 paid-rank exchange against exact PR5627 bytes. + +Retains Ali Romman's P104 local checker and all predecessor notices. The A2 +identity and complete-boundary discipline are credited to Chris R/Clear1nsight +(PR3998), ToikY(PR4019), and the scoped audits(PR4112/4152). New P104 witness, +construction and checks with substantial OpenAI Codex assistance. Apache-2.0. +""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +from copy import deepcopy +from hashlib import sha256 +import argparse,gzip,importlib.util,json,sys +HERE=Path(__file__).resolve().parent +SOURCE_WORD='162e6f13a6e3805517946309bd6247eaa45b337ab9c39621806b254b415075ec' +SOURCE_CHECKER='716d01a342467f87b14d67853d8de30740f9f2fa881afe271db0df5ef8b19697' +EXPECTED='c7545eab4e1394ba942a7ac8e4d70860d172cabda151a559fd566478aa38204b' +def need(ok,why): + if not ok:raise ValueError(why) +def construct(): + for rel,digest in [('inputs/pr5627-WORD.json.gz',SOURCE_WORD),('inputs/pr5627-local.py',SOURCE_CHECKER)]: + need(sha256((HERE/rel).read_bytes()).hexdigest()==digest,'Exact source pin '+rel) + spec=importlib.util.spec_from_file_location('retained_p104_checker',HERE/'inputs/pr5627-local.py');L=importlib.util.module_from_spec(spec);spec.loader.exec_module(L) + w=json.loads(gzip.decompress((HERE/'inputs/pr5627-WORD.json.gz').read_bytes()));v=deepcopy(w) + need(w['program'][14975]==['ADD',388,715,'-4',825] and w['program'][14977]==['ADD',340,388,'1',825],'Literal old pair') + need(w['program'][14976]==['MOVE',340,396,825,False],'Only the declared intermediate transport') + replacement=[['ADD',340,715,'-4',396],['ADD',340,388,'1',825],['ADD',388,715,'-4',127]] + need([w['frames'][f]for f in[396,825,127]]==[[13,70,416],[7,10,32,65,144,272],[1,2,4,8,16,32,64,128,256]],'Exact existing frames') + scalar=[] + for i,e in enumerate(w['program']): + if i==14975:scalar.extend(replacement) + if i not in(14975,14977) and e[0]!='MOVE':scalar.append(e[:]) + frames=[L.span(b)for b in w['frames']];n=w['public'];current=w['initial']+[None]*w['owned_fields'];active=set();out=[] + def move(r,f): + a=current[r] + if a==f:return + private=r in active + need(a is not None and (frames[f] 234 -> 127 +role 49: 734 -> 237 -> 127 +role 80: 749 -> 243 -> 127 +``` + +Each path has ranks 1 and 5. The new direct path has rank 6. For chart +operators C_A, C_B and C_D, the exact product is + +```math +(C_D C_B^{-1})(C_B C_A^{-1})=C_D C_A^{-1}. +``` + +No scalar operation uses that role between these transports. The chronological +replay checks strict chart containment, and the native verifier checks the +exact signed map and global phase. This identity applies at every positive +tensor width under the retained native implementation assumption. + +The local paid delta is `-3 H1 -3 H5 +3 H6`. Every target stays fixed. +For 00. +``` + +This is a changed physical invoice. It does not add predecessor kappa gains. +The alternative PR5613 inventory has 72 additional H5 paid calls and 72 +additional H5 targets. It has the same signed source moment, but this package +uses only the smaller PR5627 inventory. + +## 4. Complete cost and verification + +The final local word has 25,448 events, 743 independent inputs, 535 helpers, +nine owned roles, eleven owned lifetimes and peak owned occupancy two. +Its paid profile is + +```text +{1:2197, 2:456, 3:494, 4:91, 5:160, 6:21, 7:15}. +``` + +The complete caller retains 18 full forward calls, 15 thin query sites, +3,120 whole idle jobs and 3,328 main targets. Its complete invoice has +66,492 paid calls and 12,958 productive targets. The rank-mass surplus is 760. +Helpers, native normalizers, main adapters, basis operations, COPY/CLEAR, +all owned lifetimes, routes, thin queries and idles are charged. + +A separate dense integer transpose checks all 565,504 matrix entries. +The native check verifies 2,916 distinct maps. The physical caller verifies +all 7,488 contacts, 53,248 central-square columns and complete main phases. +Two rational interval engines check the same complete moment. + +The exact raw crossing lies in +`(0.00310626336369, 0.00310626336370)`. The claim is `0.00310626335`, tested +at `0.003106263355`. The gain over PR5627's claim is `0.00000185789`, +about 0.05985%. This is a small gain. +The raw ceiling is proved only for this fixed invoice on `[0,0.0034]`. +Its headroom above the claim is between `1.369e-11` and `1.370e-11`. +It is not an optimum over constructions. + +The source strictification parameters remain: power 1024, cutoff 17, +target floor 18, tail offset 1/5, reserve 10^-12 and tail decay 39/40. +The compiler checks its finite integer threshold, the preceding integer, +initial range, shifted exits and complement capacity. All 54 strict outer +conditions and four functional conditions pass. The ordinary BIT contract +remains 0.0034. + +The local scalar allowance is 220,208 and the local route allowance is +5,172,000, below the retained 10^7 bound. The complete ordinary-work bound +is 184,647,552, below 10^9. Fewer than 26,000 scalar events and the checked +coefficient bound retain the source growth bound. The paid native rank sum +is 5,986 per local word. No growth or route cost is omitted. + +The huge uniform word and complete rounded multiplier are not materialized. +These are author checks by the same AI-assisted author. Independent scientific +acceptance and a proof-kernel theorem remain absent. Source native, owned +erasure, uniform compiler, precision/tape and analytic recovery assumptions +remain. The package makes no large-gain or global-optimum claim. diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/README.md b/research/p104-a2-cleanup-composition/inputs/pr5644/README.md new file mode 100644 index 0000000000..d21c40e63f --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/README.md @@ -0,0 +1,121 @@ +# Conditional kappa 0.00310626335 from three helper cleanups + +This construction raises complete conditional kappa from +**0.00310440546 to 0.00310626335**, a gain of **0.00000185789** +(about **0.05985%**) over +[PR #5627](https://github.com/CrocSwap/integer-mult-bounds/pull/5627). +This is a small gain. The requested large improvement is not established. +The selected frontier is not changed by this package. + +Three exact helper relations remove scalar contacts on main roles 55, 49 +and 80. Each role can then replace an H1+H5 path with H6. The local paid +delta is `-3 H1 -3 H5 +3 H6`. All independent inputs, productive targets +and owned operations stay fixed. The complete caller saves 54 paid calls. + +Read [PROOF.md](PROOF.md), [WITNESS.json](WITNESS.json), +[RESULT.json](RESULT.json), [SOURCES.json](SOURCES.json), and +[VALIDATION.md](VALIDATION.md). The constructor checks every relation before +it emits the new [word](WORD.json.gz). + +| Complete quantity | Value | +| --- | ---: | +| Paid calls | 66,492 | +| Productive targets | 12,958 | +| Rank-mass surplus | 760 | +| Public inputs / helpers per full call | 743 / 535 | +| Owned roles / lifetimes / peak | 9 / 11 / 2 | +| Local events | 25,448 | +| Raw crossing | (0.00310626336369, 0.00310626336370) | +| Tested saving | 0.003106263355 | +| Claimed conditional kappa | 0.00310626335 | + +The complete cost includes helpers, native maps, input/output normalizers, +main adapters, scalar bases, COPY/CLEAR, allocation, routes, thin queries, +whole idles, compiler completion and rounding. Two rational interval engines, +all compiler conditions and all 58 outer conditions pass. The ordinary BIT +contract stays at 0.0034. The fixed-invoice ceiling is the raw crossing above; +it is not a ceiling over constructions. + +## Reproduce + +Use Python 3.12 and its standard library, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/p104-neutral-helper-cleanup --check-only +python3 -B scripts/research_package.py --package research/p104-neutral-helper-cleanup +``` + +The registered command runs normally and with `-O`. Expected markers are +`PASS_P104_NEUTRAL_HELPER_KAPPA_00310626335` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. Direct replay needs no Git or network: + +```sh +python3 -I -W error -B research/p104-neutral-helper-cleanup/verify.py +python3 -I -W error -B -O research/p104-neutral-helper-cleanup/verify.py +``` + +Normal replay is read-only. `--write` regenerates the word and receipt. +The verifier authenticates the exact source archive and all 36 payload files +before it imports source code. It checks all 565,504 endpoint coefficients, +2,916 signed native maps, the complete physical caller and the full cost. +Controls reject a false cancellation, wrong cut, missing input basis, +missing owned erasure, extra target credit and unpaid query. The native, +controller and pricing checks retain their own controls. + +## Source and credit + +The consumed source is [PR #5627](https://github.com/CrocSwap/integer-mult-bounds/pull/5627) +at `ed4dc88a09a7d201971f6603b8c2074e95dd9c32`: +[source proof](https://github.com/aliromman/integer-mult-bounds/blob/ed4dc88a09a7d201971f6603b8c2074e95dd9c32/research/p104-helper-subspace-splits/PROOF.md), +[source word](https://github.com/aliromman/integer-mult-bounds/blob/ed4dc88a09a7d201971f6603b8c2074e95dd9c32/research/p104-helper-subspace-splits/WORD.json.gz), +and [source notices](https://github.com/aliromman/integer-mult-bounds/blob/ed4dc88a09a7d201971f6603b8c2074e95dd9c32/research/p104-helper-subspace-splits/NOTICE). +Its official self-contained export is retained. Reproduction does not require +a cached unmerged Git object. The exact word, caller and all shared proof +engines are unchanged source inputs. The derived pricing file changes only +the declared claim, comparison and paid count; its byte-level derivation is checked. + +Ali Romman supplied the new three relations with substantial OpenAI Codex +assistance. The same assistant performed the author checks; no subagents or +independent scientific review. The helper-boundary method extends +[PR #5602](https://github.com/CrocSwap/integer-mult-bounds/pull/5602). +The source package supplies the complete composition of +[PR #5601](https://github.com/CrocSwap/integer-mult-bounds/pull/5601), +[PR #5605](https://github.com/CrocSwap/integer-mult-bounds/pull/5605), +[PR #5612](https://github.com/CrocSwap/integer-mult-bounds/pull/5612), +[PR #5606](https://github.com/CrocSwap/integer-mult-bounds/pull/5606) +and [PR #5599](https://github.com/CrocSwap/integer-mult-bounds/pull/5599). +Its notices credit flyingviper's relays, Scratch-net's prepared helper, +Pierre-Loic Doulcet's cascade, Joel Pulikkan, DreamingOfClouds, thu-nmrc, +Gareth Davidson, David Arias, Cinna Davis, Jacob Alan Sussman, zxv and +Cao Yifan, with the earlier geometry, BIT and analytic sources. +All notices remain in the retained export and pricing module. Apache-2.0. + +The discovery first passed on +[PR #5613](https://github.com/CrocSwap/integer-mult-bounds/pull/5613) at +`32f23af8790cc3c435bb1f495d861332b4f000e3`. That source has the same signed +moment but 72 more H5 paid calls and 72 more H5 targets. It is comparison +evidence, not the consumed input. Its counts are not combined with this receipt. + +## Coordination and limits + +The frozen research base is canonical main +`6cf7a683f447b9f1e2333791907fd92be5009a63`, priority revision 7. +The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639) +records the source pins, live overlap checks and released finite screens. +The separate Discussion5600 main-port retirement campaign is excluded. +The final publication checkpoint is recorded in `VALIDATION.md`. + +The five selected assumptions remain: native implementation at all widths, +owned erasure, uniform compiler closure, precision/tape cost and analytic +recovery. The helper endpoint contract also remains. The huge uniform word +and complete rounded multiplier are not materialized. This package does not +claim independent acceptance, a proof-kernel theorem or global optimality. + +## Open next questions + +An independent reviewer can check the three prefix relations and transport +products, then replay the full package. Further coordinated bases may remove +more scalar contacts, but the larger exploratory screens have not produced +a new complete gain. A new construction must first check current claims and +must include every changed target and paid operation. [TASK.json](TASK.json) +records the next bounded question and its blockers. diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/RESULT.json b/research/p104-a2-cleanup-composition/inputs/pr5644/RESULT.json new file mode 100644 index 0000000000..2908bf95db --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/RESULT.json @@ -0,0 +1,680 @@ +{ + "authenticated_source_files": 36, + "changes": [ + { + "cancellation": [ + [ + "ADD", + 291, + 293, + "1", + 234 + ], + [ + "SCALE", + 291, + "-1/2", + 234 + ] + ], + "cut": 10627, + "events": 25446, + "frame": 234, + "helper": 291, + "paid": { + "1": 2199, + "2": 456, + "3": 494, + "4": 91, + "5": 162, + "6": 19, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 291, + 39, + "1", + 3 + ], + [ + "ADD", + 291, + 293, + "-1/2", + 3 + ], + [ + "ADD", + 291, + 303, + "1", + 3 + ] + ], + "removed_scalar_events": [ + [ + "SCALE", + 291, + "-1/2", + 234 + ], + [ + "ADD", + 291, + 289, + "1/2", + 234 + ], + [ + "ADD", + 291, + 39, + "1/2", + 234 + ], + [ + "ADD", + 291, + 40, + "1/2", + 234 + ], + [ + "ADD", + 291, + 18, + "-1/2", + 234 + ], + [ + "ADD", + 291, + 55, + "-1", + 234 + ] + ], + "scalar": 220140 + }, + { + "cancellation": [ + [ + "ADD", + 321, + 22, + "-2", + 237 + ], + [ + "ADD", + 321, + 320, + "3/2", + 237 + ], + [ + "ADD", + 321, + 330, + "-2", + 237 + ] + ], + "cut": 11072, + "events": 25446, + "frame": 237, + "helper": 321, + "paid": { + "1": 2198, + "2": 456, + "3": 494, + "4": 91, + "5": 161, + "6": 20, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 321, + 34, + "2", + 3 + ], + [ + "ADD", + 321, + 320, + "2", + 3 + ], + [ + "ADD", + 321, + 330, + "-2", + 3 + ] + ], + "removed_scalar_events": [ + [ + "ADD", + 321, + 320, + "1", + 237 + ], + [ + "ADD", + 321, + 23, + "-1", + 237 + ], + [ + "ADD", + 321, + 22, + "-1", + 237 + ], + [ + "ADD", + 321, + 108, + "1", + 237 + ], + [ + "ADD", + 321, + 49, + "-1", + 237 + ] + ], + "scalar": 220164 + }, + { + "cancellation": [ + [ + "ADD", + 369, + 26, + "-2", + 243 + ], + [ + "ADD", + 369, + 368, + "3/2", + 243 + ], + [ + "ADD", + 369, + 378, + "2", + 243 + ] + ], + "cut": 11718, + "events": 25448, + "frame": 243, + "helper": 369, + "paid": { + "1": 2197, + "2": 456, + "3": 494, + "4": 91, + "5": 160, + "6": 21, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 369, + 3, + "2", + 3 + ], + [ + "ADD", + 369, + 372, + "2", + 3 + ], + [ + "ADD", + 369, + 378, + "2", + 3 + ], + [ + "ADD", + 369, + 382, + "2", + 3 + ], + [ + "ADD", + 369, + 383, + "-2", + 3 + ] + ], + "removed_scalar_events": [ + [ + "ADD", + 369, + 368, + "1", + 243 + ], + [ + "ADD", + 369, + 26, + "-1", + 243 + ], + [ + "ADD", + 369, + 95, + "-1", + 243 + ], + [ + "ADD", + 369, + 8, + "1", + 243 + ], + [ + "ADD", + 369, + 80, + "-1", + 243 + ] + ], + "scalar": 220208 + } + ], + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000132965805256205580454152", + "upper": "0.000000132965805256205580454153" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "543596087/175000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "185789/100000000000", + "kappa": "62125267/20000000000", + "kappa_decimal": ".00310626335", + "margin_at_previous": { + "lower": "0.451550879336614603359787426152", + "upper": "0.451550879336614603359787426153" + }, + "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_paid_rank_mass": 5986, + "local_routes": 5172000, + "local_scalar": 220208, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "ordinary_BIT": { + "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": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "6088276171595651231307/1960000000000000000000000", + "fused_gaussian": "6088276171586953693921/1960000000000000000000000", + "global_coordinate_router": "2174384347/700000000000", + "group_bit_router": "3044138086493476846959/980000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6088276170195651231307/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802338276171595651231307/1960000000000000000000000" + }, + "parameters": { + "a": "2174384347/700000000000", + "b": "869753739/280000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "1782338276170195651231307/1960000000000000000000000", + "complex_uniform_saving": "543596087/175000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "62125267/20000000000", + "lambda_": "398757494659/400000000000", + "lambda_prime": "1395651231307/1400000000000", + "layout": "1/1400000000000", + "q": "4348768693/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "621252671/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "205615653/700000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177661723831904348768693/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595651231307/1960000000000000000000000", + "cap_above_band": "802338276170195651231307/1960000000000000000000000", + "cap_below_cell": "177661723828404348768693/1960000000000000000000000", + "cap_below_phase_cell_power": "2137661723829804348768693/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "7880246261/280000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586953693921/1960000000000000000000000", + "gaussian_above_main": "695651231307/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "3493476846959/980000000000000000000000", + "group_gauge_power_slack": "177661723831834348768693/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "348912807827/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "687646465400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "559130246261/392000000000000000000000", + "leaf_saving_above_effective": "279130246261/392000000000000000000000", + "main_transform_above_kappa": "4195651231307/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "53897825615657/700000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "1395651231309/1400000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "559130246261/392000000000000000000000", + "q_positive": "4348768693/1400000000000", + "short_record_fallback": "279130246261/280000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595651231307/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41106, + "16": 416, + "2": 8208, + "24": 416, + "3": 8892, + "32": 416, + "4": 1638, + "40": 416, + "48": 416, + "5": 2880, + "56": 416, + "6": 378, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66492, + "previous_open_pr5627": "155220273/50000000000", + "productive_fields": 12958, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-185059801945251167500572380988789019128885006440939063323697675/784637716923335095479473677900958302012794430558004314112", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "1369/100000000000000", + "137/10000000000000" + ], + "raw_root_interval": [ + "310626336369/100000000000000", + "31062633637/10000000000000" + ], + "relative_gain_percent": "9289450/155220273", + "strictification": { + "alpha": { + "lower": "0.999999999991151995165679182213", + "upper": "0.999999999991151995165679182214" + }, + "cutoff": 17, + "delta": { + "lower": "0.967530914044170735058316873915", + "upper": "0.967530914044170735058316873916" + }, + "floor": 18, + "gamma": { + "lower": "0.968140817783099208114307070153", + "upper": "0.968140817783099208114307070154" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "39/40", + "tail_offset": "1/5", + "tested": "621252671/200000000000" + }, + "targets": { + "1": 36, + "145": 208, + "17": 416, + "2": 72, + "25": 416, + "33": 416, + "4": 1638, + "41": 416, + "49": 416, + "5": 108, + "57": 416, + "65": 416, + "7": 90, + "73": 208, + "8": 288, + "9": 7398 + }, + "whole_idle_jobs": 3120 + }, + "limits": [ + "The five selected framework assumptions and helper-endpoint contract remain.", + "The enormous uniform word and complete rounded multiplier are not materialized.", + "These author checks are not independent scientific review or a proof-kernel theorem.", + "The improvement is small. No large gain or global optimum is established." + ], + "local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2197, + "2": 456, + "3": 494, + "4": 91, + "5": 160, + "6": 21, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220208 + }, + "local_helper_delta": {}, + "local_paid_delta": { + "1": -3, + "5": -3, + "6": 3 + }, + "native": { + "distinct_maps": 2916, + "helper_normalizers": 1070, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "92eef26313b53686f5f78c181e8a75549280be0a714dbd069ae2cc2f24bbd820", + "wrong_phase_rejected": true + }, + "negative_controls": { + "extra_target_credit": "Every productive helper has a native target", + "false_cancellation": "Exact prefix relation on every input", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "missing_input_basis": "All public and owned rows", + "missing_owned_erasure": "All public and owned exits", + "unpaid_query": "Complete field and call counts", + "wrong_cut": "Exact chronological anchor" + }, + "physical_caller": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 565504, + "columns": 752 + }, + "source_commit": "ed4dc88a09a7d201971f6603b8c2074e95dd9c32", + "source_local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2200, + "2": 456, + "3": 494, + "4": 91, + "5": 163, + "6": 18, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220154 + }, + "status": "PASS_P104_NEUTRAL_HELPER_KAPPA_00310626335" +} diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/SOURCES.json b/research/p104-a2-cleanup-composition/inputs/pr5644/SOURCES.json new file mode 100644 index 0000000000..410fd77bfd --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/SOURCES.json @@ -0,0 +1,34 @@ +{ + "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63", + "files": [ + { + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "path": "docs/research/agent-task-catalog.json", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72", + "usage": "provenance" + }, + { + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "path": "certificates/selected-result.json", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903", + "usage": "provenance" + }, + { + "git_blob": "bc900f0a1561b17b35492a80d10ae94f790d8378", + "path": "research/p104-neutral-helper-cleanup/inputs/pr5627-source.tar", + "pin": "head:47da58a1446ff744c6a558a16719024375e77e81:research/p104-neutral-helper-cleanup/inputs/pr5627-source.tar", + "sha256": "86c6bb839e14d79175ff8f3ed80b51a02d5c51a04deb0eff7ccea1afbe72923b", + "usage": "input" + } + ], + "schema_version": 1, + "source_export": { + "commit": "ed4dc88a09a7d201971f6603b8c2074e95dd9c32", + "files": 36, + "git_blob": "bc900f0a1561b17b35492a80d10ae94f790d8378", + "local_path": "inputs/pr5627-source.tar", + "package": "research/p104-helper-subspace-splits", + "sha256": "86c6bb839e14d79175ff8f3ed80b51a02d5c51a04deb0eff7ccea1afbe72923b", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5627" + } +} diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/WITNESS.json b/research/p104-a2-cleanup-composition/inputs/pr5644/WITNESS.json new file mode 100644 index 0000000000..8d4f38c5c9 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/WITNESS.json @@ -0,0 +1,80 @@ +[ + { + "anchor": [ + "ADD", + 18, + 291, + "-1/2", + 234 + ], + "cancel": { + "293": "-1" + }, + "cut": 10627, + "frame": 234, + "gain": 0.0, + "helper": 291, + "output": { + "291": "-2", + "293": "-1", + "303": "2", + "39": "2" + }, + "removed": 6, + "reverse": false + }, + { + "anchor": [ + "ADD", + 320, + 321, + "-1", + 237 + ], + "cancel": { + "22": "2", + "320": "-3/2", + "330": "2" + }, + "cut": 11072, + "frame": 237, + "gain": 0.0, + "helper": 321, + "output": { + "320": "-2", + "321": "1", + "330": "2", + "34": "-2" + }, + "removed": 5, + "reverse": false + }, + { + "anchor": [ + "ADD", + 368, + 369, + "-1", + 243 + ], + "cancel": { + "26": "2", + "368": "-3/2", + "378": "-2" + }, + "cut": 11718, + "frame": 243, + "gain": 0.0, + "helper": 369, + "output": { + "3": "-2", + "369": "1", + "372": "-2", + "378": "-2", + "382": "-2", + "383": "2" + }, + "removed": 5, + "reverse": false + } +] diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/WORD.json.gz b/research/p104-a2-cleanup-composition/inputs/pr5644/WORD.json.gz new file mode 100644 index 0000000000..0bd3cff775 Binary files /dev/null and b/research/p104-a2-cleanup-composition/inputs/pr5644/WORD.json.gz differ diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/construct.py b/research/p104-a2-cleanup-composition/inputs/pr5644/construct.py new file mode 100644 index 0000000000..1d9ff07f57 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/construct.py @@ -0,0 +1,117 @@ +"""Apply three exact neutral helper relations and join unused transports. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The helper boundary identity extends the retained PR5602 construction. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q + + +def coalesce(word, L): + out = deepcopy(word) + actual = word['initial'] + [None]*word['owned_fields'] + desired, program = actual[:], [] + + def flush(role): + if actual[role] != desired[role]: + program.append(['MOVE', role, actual[role], desired[role], role >= word['public']]) + actual[role] = desired[role] + + for event in word['program']: + op, role = event[:2] + if op == 'MOVE': + L.need(desired[role] == event[2], 'Chronological transport source') + desired[role] = event[3] + elif op == 'INIT': + L.need(actual[role] is None, 'Fresh owned lifetime') + actual[role] = desired[role] = event[2] + program.append(event[:]) + else: + flush(role) + if op in ('ADD', 'COPY'): + flush(event[2]) + program.append(event[:]) + if op == 'CLEAR': + actual[role] = desired[role] = None + for role in range(word['public']): + flush(role) + out['program'] = program + return out + + +def relation(word, witness, L): + h, cut, frame = (witness[k] for k in ('helper', 'cut', 'frame')) + n, owned = word['public'], word['owned_fields'] + main = set(word['live']) | {r+112 for r in word['live']} + L.need(h < n and h not in main and witness['reverse'] is False, 'Forward public helper') + L.need(word['program'][cut] == witness['anchor'], 'Exact chronological anchor') + L.need(word['final'][h] == frame, 'The target boundary stays fixed') + rows = [{r:Q(1)} if r < n else {} for r in range(n+owned)] + current = word['initial'] + [None]*owned + for event in word['program'][:cut+1]: + op, role = event[:2] + if op == 'MOVE': + current[role] = event[3] + elif op in ('INIT', 'CLEAR'): + rows[role] = {} + current[role] = event[2] if op == 'INIT' else None + elif op == 'SCALE': + rows[role] = {j:Q(event[-2])*a for j,a in rows[role].items()} + elif op == 'COPY': + rows[role] = {j:Q(event[-2])*a for j,a in rows[event[2]].items()} + else: + L.add(rows[role], rows[event[2]], Q(event[-2])) + output = {int(j):Q(a) for j,a in witness['output'].items()} + cancel = {int(j):Q(a) for j,a in witness['cancel'].items()} + initial = word['initial'][h] + L.need(h in output and h not in cancel and all(j < n and word['initial'][j] == initial + for j in output), 'One independent input chart') + L.need(current[h] == frame and all(current[j] == frame for j in cancel), + 'One cancellation chart') + row = rows[h].copy() + for role, coefficient in cancel.items(): + L.add(row, rows[role], -coefficient) + L.need(row == output, 'Exact prefix relation on every input') + scale = output[h] + L.need(scale and abs(scale.numerator) & (abs(scale.numerator)-1) == 0 + and scale.denominator & (scale.denominator-1) == 0, 'Invertible dyadic coefficient') + tail = word['program'][cut+1:] + L.need(not any(e[0] in ('ADD', 'COPY') and e[2] == h for e in tail), 'No later helper read') + removed = [e for e in tail if e[1] == h] + L.need(len(removed) == witness['removed'] and all(e[0] in ('ADD', 'SCALE') for e in removed), + 'Only declared scalar cleanup is removed') + preparation = [['ADD', h, j, str(-a/scale), initial] for j,a in sorted(output.items()) if j != h] + cancellation = [['ADD', h, j, str(-a), frame] for j,a in sorted(cancel.items())] + if scale != 1: + cancellation.append(['SCALE', h, str(1/scale), frame]) + out = deepcopy(word) + out['program'] = preparation + word['program'][:cut+1] + cancellation + [e for e in tail if e[1] != h] + out = coalesce(out, L) + return out, {'helper':h, 'cut':cut, 'frame':frame, 'removed_scalar_events':removed, + 'preparation':preparation, 'cancellation':cancellation} + + +def owned_events(word): + n = word['public'] + return [e for e in word['program'] if e[1] >= n or (e[0] in ('ADD', 'COPY') and e[2] >= n)] + + +def construct(source, witnesses, L): + L.need([c['helper'] for c in witnesses] == [291,321,369], 'Three declared helper relations') + word, receipts = deepcopy(source), [] + before = L.replay(word) + for witness in witnesses: + old = word + word, receipt = relation(word, witness, L) + after = L.replay(word) + delta = Counter(after['paid']) + delta.subtract(before['paid']) + L.need({r:v for r,v in delta.items() if v} == {1:-1,5:-1,6:1}, 'One H1+H5 path becomes H6') + L.need(after['helpers'] == before['helpers'] and word['initial'] == old['initial'] + and word['final'] == old['final'], 'Every target and independent input stays fixed') + L.need(owned_events(word) == owned_events(old), 'Every owned operation is retained in order') + receipt.update(paid=after['paid'], events=len(word['program']), scalar=after['real_scalar_allowance']) + receipts.append(receipt) + before = after + return word, receipts, before diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/inputs/pr5627-source.tar b/research/p104-a2-cleanup-composition/inputs/pr5644/inputs/pr5627-source.tar new file mode 100644 index 0000000000..bc900f0a15 Binary files /dev/null and b/research/p104-a2-cleanup-composition/inputs/pr5644/inputs/pr5627-source.tar differ diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/pricing.py b/research/p104-a2-cleanup-composition/inputs/pr5644/pricing.py new file mode 100644 index 0000000000..dc7f71a781 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/pricing.py @@ -0,0 +1,174 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00310626335'), Q('.003106263355') +PREVIOUS = Q('.00310440546') + + +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()) == 12958 and sum(paid.values()) == 66492, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,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**12),Q(39,40) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + 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':'.00310626335','previous_open_pr5627':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), + 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-a2-cleanup-composition/inputs/pr5644/sources.py b/research/p104-a2-cleanup-composition/inputs/pr5644/sources.py new file mode 100644 index 0000000000..ea32e0a120 --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5644/sources.py @@ -0,0 +1,61 @@ +"""Authenticate the retained PR5627 export before any source import. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The archive checks follow the repository exporter and flyingviper's PR5613. +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import io +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +@contextmanager +def sources(): + pin = json.loads((HERE/'SOURCES.json').read_bytes())['source_export'] + raw = (HERE/pin['local_path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'Exact predecessor archive SHA256') + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'Exact retained archive Git blob') + with tempfile.TemporaryDirectory(prefix='p104-neutral-source-') as directory: + root, names = Path(directory), set() + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:') as bundle: + for member in bundle.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and '\\' not in member.name and ':' not in member.name, + 'Regular relative source path') + need(member.name not in names, 'Unique source path') + names.add(member.name) + target = root.joinpath(*path.parts) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(bundle.extractfile(member).read()) + manifest = json.loads((root/'.research-export.json').read_bytes()) + need(manifest['commit'] == pin['commit'] and manifest['package'] == pin['package'] + and len(manifest['files']) == pin['files'], 'Exact source commit and inventory') + need(names == {'.research-export.json'} | {r['path'] for r in manifest['files']}, + 'No missing or additional source payload') + for row in manifest['files']: + payload = (root/row['path']).read_bytes() + need(len(payload) == row['size'] and sha256(payload).hexdigest() == row['sha256'], + 'Authenticated payload: '+row['path']) + yield root/pin['package'], root diff --git a/research/p104-a2-cleanup-composition/inputs/pr5650/FULL-RESULT.json b/research/p104-a2-cleanup-composition/inputs/pr5650/FULL-RESULT.json new file mode 100644 index 0000000000..e64b25fb0d --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5650/FULL-RESULT.json @@ -0,0 +1,789 @@ +{ + "candidate_payload_sha256": "42fe73e3240340aa185aab3cf976f8f6b783603b4d5513345519a260c1253d4a", + "cleanup_changes": [ + { + "cancellation": [ + [ + "ADD", + 291, + 293, + "1", + 234 + ], + [ + "SCALE", + 291, + "-1/2", + 234 + ] + ], + "cut": 10627, + "events": 25447, + "frame": 234, + "helper": 291, + "paid": { + "1": 2199, + "2": 457, + "3": 493, + "4": 91, + "5": 161, + "6": 20, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 291, + 39, + "1", + 3 + ], + [ + "ADD", + 291, + 293, + "-1/2", + 3 + ], + [ + "ADD", + 291, + 303, + "1", + 3 + ] + ], + "removed_scalar_events": [ + [ + "SCALE", + 291, + "-1/2", + 234 + ], + [ + "ADD", + 291, + 289, + "1/2", + 234 + ], + [ + "ADD", + 291, + 39, + "1/2", + 234 + ], + [ + "ADD", + 291, + 40, + "1/2", + 234 + ], + [ + "ADD", + 291, + 18, + "-1/2", + 234 + ], + [ + "ADD", + 291, + 55, + "-1", + 234 + ] + ], + "scalar": 220152 + }, + { + "cancellation": [ + [ + "ADD", + 321, + 22, + "-2", + 237 + ], + [ + "ADD", + 321, + 320, + "3/2", + 237 + ], + [ + "ADD", + 321, + 330, + "-2", + 237 + ] + ], + "cut": 11072, + "events": 25447, + "frame": 237, + "helper": 321, + "paid": { + "1": 2198, + "2": 457, + "3": 493, + "4": 91, + "5": 160, + "6": 21, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 321, + 34, + "2", + 3 + ], + [ + "ADD", + 321, + 320, + "2", + 3 + ], + [ + "ADD", + 321, + 330, + "-2", + 3 + ] + ], + "removed_scalar_events": [ + [ + "ADD", + 321, + 320, + "1", + 237 + ], + [ + "ADD", + 321, + 23, + "-1", + 237 + ], + [ + "ADD", + 321, + 22, + "-1", + 237 + ], + [ + "ADD", + 321, + 108, + "1", + 237 + ], + [ + "ADD", + 321, + 49, + "-1", + 237 + ] + ], + "scalar": 220176 + }, + { + "cancellation": [ + [ + "ADD", + 369, + 26, + "-2", + 243 + ], + [ + "ADD", + 369, + 368, + "3/2", + 243 + ], + [ + "ADD", + 369, + 378, + "2", + 243 + ] + ], + "cut": 11718, + "events": 25449, + "frame": 243, + "helper": 369, + "paid": { + "1": 2197, + "2": 457, + "3": 493, + "4": 91, + "5": 159, + "6": 22, + "7": 15 + }, + "preparation": [ + [ + "ADD", + 369, + 3, + "2", + 3 + ], + [ + "ADD", + 369, + 372, + "2", + 3 + ], + [ + "ADD", + 369, + 378, + "2", + 3 + ], + [ + "ADD", + 369, + 382, + "2", + 3 + ], + [ + "ADD", + 369, + 383, + "-2", + 3 + ] + ], + "removed_scalar_events": [ + [ + "ADD", + 369, + 368, + "1", + 243 + ], + [ + "ADD", + 369, + 26, + "-1", + 243 + ], + [ + "ADD", + 369, + 95, + "-1", + 243 + ], + [ + "ADD", + 369, + 8, + "1", + 243 + ], + [ + "ADD", + 369, + 80, + "-1", + 243 + ] + ], + "scalar": 220220 + } + ], + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000132842965546357133068088", + "upper": "0.000000132842965546357133068089" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "2174511279/700000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "18133/100000000000", + "kappa": "77661117/25000000000", + "kappa_decimal": ".00310644468", + "margin_at_previous": { + "lower": "0.044072122145674172679584329881", + "upper": "0.044072122145674172679584329882" + }, + "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_paid_rank_mass": 5986, + "local_routes": 5172000, + "local_scalar": 220220, + "peak_owned_fields": 2, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "ordinary_BIT": { + "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": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1217726315679130195489/392000000000000000000000", + "fused_gaussian": "1217726315677390586467/392000000000000000000000", + "global_coordinate_router": "1087255639/350000000000", + "group_bit_router": "1522157894946738233083/490000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "1217726315399130195489/392000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "160467726315679130195489/392000000000000000000000" + }, + "parameters": { + "a": "1087255639/350000000000", + "b": "4349022557/1400000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "356467726315399130195489/392000000000000000000000", + "complex_uniform_saving": "2174511279/700000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "77661117/25000000000", + "lambda_": "398757422127/400000000000", + "lambda_prime": "279130195489/280000000000", + "layout": "1/1400000000000", + "q": "869804511/280000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "621288937/200000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "102744361/350000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "35532273685020869804511/196000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "1119130195489/392000000000000000000000", + "cap_above_band": "160467726315399130195489/392000000000000000000000", + "cap_below_cell": "35532273684320869804511/392000000000000000000000", + "cap_below_phase_cell_power": "427532273684600869804511/392000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "39400977443/1400000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "1117390586467/392000000000000000000000", + "gaussian_above_main": "139130195489/196000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "1746738233083/490000000000000000000000", + "group_gauge_power_slack": "35532273685006869804511/196000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "697825488723/700000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "687737130400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "2795650977443/1960000000000000000000000", + "leaf_saving_above_effective": "1395650977443/1960000000000000000000000", + "main_transform_above_kappa": "839130195489/392000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "26948912744363/350000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "1395650977447/1400000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "2795650977443/1960000000000000000000000", + "q_positive": "869804511/280000000000", + "short_record_fallback": "1395650977443/1400000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "159250000001119130195489/392000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41106, + "16": 416, + "2": 8226, + "24": 416, + "3": 8874, + "32": 416, + "4": 1638, + "40": 416, + "48": 416, + "5": 2862, + "56": 416, + "6": 396, + "64": 416, + "7": 270, + "72": 208 + }, + "paid_calls": 66492, + "previous_open_pr5627": "62125267/20000000000", + "productive_fields": 12958, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-46262147594541099508843083517426769431530571502553738606261941/196159429230833773869868419475239575503198607639501078528", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "1581/100000000000000", + "791/50000000000000" + ], + "raw_root_interval": [ + "310644469581/100000000000000", + "155322234791/50000000000000" + ], + "relative_gain_percent": "362660/62125267", + "strictification": { + "alpha": { + "lower": "0.999999999989000727034318538265", + "upper": "0.999999999989000727034318538266" + }, + "cutoff": 17, + "delta": { + "lower": "0.967531019705250195840076347630", + "upper": "0.967531019705250195840076347631" + }, + "floor": 18, + "gamma": { + "lower": "0.968151249902445992824910038589", + "upper": "0.968151249902445992824910038590" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "39/40", + "tail_offset": "1/5", + "tested": "621288937/200000000000" + }, + "targets": { + "1": 36, + "145": 208, + "17": 416, + "2": 72, + "25": 416, + "33": 416, + "4": 1638, + "41": 416, + "49": 416, + "5": 108, + "57": 416, + "65": 416, + "7": 90, + "73": 208, + "8": 288, + "9": 7398 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "extra_target_credit": "Every productive helper has a native target", + "false_cleanup_cancellation": "Exact prefix relation on every input", + "missing_A2_correction": "All public and owned rows", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "missing_input_basis": "All public and owned rows", + "missing_owned_erasure": "All public and owned exits", + "source_byte_mutation_inputs/pr5643/WORD.json.gz": "Exact retained source SHA256 inputs/pr5643/WORD.json.gz", + "source_byte_mutation_inputs/pr5643/construct.py": "Exact retained source SHA256 inputs/pr5643/construct.py", + "source_byte_mutation_inputs/pr5643/inputs/pr5627-WORD.json.gz": "Exact retained source SHA256 inputs/pr5643/inputs/pr5627-WORD.json.gz", + "source_byte_mutation_inputs/pr5643/inputs/pr5627-local.py": "Exact retained source SHA256 inputs/pr5643/inputs/pr5627-local.py", + "source_byte_mutation_inputs/pr5644/NOTICE": "Exact retained source SHA256 inputs/pr5644/NOTICE", + "source_byte_mutation_inputs/pr5644/PROOF.md": "Exact retained source SHA256 inputs/pr5644/PROOF.md", + "source_byte_mutation_inputs/pr5644/README.md": "Exact retained source SHA256 inputs/pr5644/README.md", + "source_byte_mutation_inputs/pr5644/RESULT.json": "Exact retained source SHA256 inputs/pr5644/RESULT.json", + "source_byte_mutation_inputs/pr5644/SOURCES.json": "Exact retained source SHA256 inputs/pr5644/SOURCES.json", + "source_byte_mutation_inputs/pr5644/TASK.json": "Exact retained source SHA256 inputs/pr5644/TASK.json", + "source_byte_mutation_inputs/pr5644/VALIDATION.md": "Exact retained source SHA256 inputs/pr5644/VALIDATION.md", + "source_byte_mutation_inputs/pr5644/VERIFY.json": "Exact retained source SHA256 inputs/pr5644/VERIFY.json", + "source_byte_mutation_inputs/pr5644/WITNESS.json": "Exact retained source SHA256 inputs/pr5644/WITNESS.json", + "source_byte_mutation_inputs/pr5644/WORD.json.gz": "Exact retained source SHA256 inputs/pr5644/WORD.json.gz", + "source_byte_mutation_inputs/pr5644/construct.py": "Exact retained source SHA256 inputs/pr5644/construct.py", + "source_byte_mutation_inputs/pr5644/inputs/pr5627-source.tar": "Exact retained source SHA256 inputs/pr5644/inputs/pr5627-source.tar", + "source_byte_mutation_inputs/pr5644/pricing.py": "Exact retained source SHA256 inputs/pr5644/pricing.py", + "source_byte_mutation_inputs/pr5644/sources.py": "Exact retained source SHA256 inputs/pr5644/sources.py", + "source_byte_mutation_inputs/pr5644/verify.py": "Exact retained source SHA256 inputs/pr5644/verify.py", + "undercharged_A2_child": "Complete rank surplus", + "unpaid_query": "Complete field and call counts", + "wrong_A2_contact_frame": "Scalar destination and coefficient", + "wrong_cleanup_cut": "Exact chronological anchor" + }, + "delta_vs_pr5627": { + "1": -3, + "2": 1, + "3": -1, + "5": -4, + "6": 4 + }, + "delta_vs_pr5643": { + "1": -3, + "5": -3, + "6": 3 + }, + "delta_vs_pr5644": { + "2": 1, + "3": -1, + "5": -1, + "6": 1 + }, + "foundation_files": [ + "research/p104-productive-controller/caller.py", + "research/p104-productive-controller/CONTROLLER.json", + "research/joint-helper-lattice/CONTROLLER.json", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/higher-moment-strictification/verify.py", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/query-thinned-controllers/RESULT.json", + "research/p104-helper-subspace-splits/inputs/PR5580-WORD.json.gz", + "research/p104-helper-subspace-splits/inputs/PR5565-WORD.json.gz", + "research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz", + "research/p104-helper-subspace-splits/inputs/PR5602-construct.py", + "research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json", + "research/p104-helper-subspace-splits/inputs/PR5605-construct.py", + "research/p104-helper-subspace-splits/inputs/PR5606-construct.py", + "research/p104-helper-subspace-splits/inputs/PR5612-delayed.py" + ], + "local": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2197, + "2": 457, + "3": 493, + "4": 91, + "5": 159, + "6": 22, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220220 + }, + "native": { + "distinct_maps": 2916, + "helper_normalizers": 1070, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "4b1cbe1539a57fa2fac54b3d4e7a509bc9fe6cada4ad9f7ce29814f71c4b6760", + "wrong_phase_rejected": true + }, + "physical": { + "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 + ] + }, + "previous_local": { + "pr5627": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2200, + "2": 456, + "3": 494, + "4": 91, + "5": 163, + "6": 18, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220154 + }, + "pr5643": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2200, + "2": 457, + "3": 493, + "4": 91, + "5": 162, + "6": 19, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220166 + }, + "pr5644": { + "endpoint_coefficients": 565504, + "helpers": { + "1": 2, + "2": 4, + "4": 91, + "5": 6, + "7": 5, + "8": 16, + "9": 411 + }, + "owned_fields": 9, + "owned_lifetimes": 11, + "paid": { + "1": 2197, + "2": 456, + "3": 494, + "4": 91, + "5": 160, + "6": 21, + "7": 15 + }, + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220208 + } + }, + "sources": { + "pr5643": "a3ff5c628bfc8825553d62d913f3e91f75d6825f", + "pr5644": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02" + }, + "status": "PASS_P104_COMPOSED_KAPPA_00310644468", + "target_delta": {}, + "transpose": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 565504, + "columns": 752 + } +} diff --git a/research/p104-a2-cleanup-composition/inputs/pr5650/NOTICE b/research/p104-a2-cleanup-composition/inputs/pr5650/NOTICE new file mode 100644 index 0000000000..329998cf2d --- /dev/null +++ b/research/p104-a2-cleanup-composition/inputs/pr5650/NOTICE @@ -0,0 +1,427 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. + +P104 A2 and neutral-helper cleanup composition, 25 October 2026 + +New common-word construction, source-bound verifier, exact composition audit +and scoped component triage prepared for zxv (https://github.com/zxv) with +substantial OpenAI Codex assistance and three subagent investigations. +Ali Romman (https://github.com/aliromman) supplies PR5644 cleanup identities +and constructor. PR5643 supplies the emitted A2 exchange. Full predecessor +notices and licenses are retained unchanged in the source archive and inputs. +https://github.com/CrocSwap/integer-mult-bounds/pull/5643 +https://github.com/CrocSwap/integer-mult-bounds/pull/5644 +Apache-2.0. diff --git a/research/p104-a2-cleanup-composition/inputs/pr5650/WORD.json.gz b/research/p104-a2-cleanup-composition/inputs/pr5650/WORD.json.gz new file mode 100644 index 0000000000..92e858d5db Binary files /dev/null and b/research/p104-a2-cleanup-composition/inputs/pr5650/WORD.json.gz differ diff --git a/research/p104-a2-cleanup-composition/pricing.py b/research/p104-a2-cleanup-composition/pricing.py new file mode 100644 index 0000000000..17e649cae0 --- /dev/null +++ b/research/p104-a2-cleanup-composition/pricing.py @@ -0,0 +1,174 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('.00310644469'), Q('.003106444692') +PREVIOUS = Q('.00310626335') + + +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()) == 12958 and sum(paid.values()) == 66492, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,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**12),Q(39,40) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + 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':'.00310644469','previous_open_pr5644':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), + 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-a2-cleanup-composition/verify.py b/research/p104-a2-cleanup-composition/verify.py new file mode 100644 index 0000000000..4f1fed596e --- /dev/null +++ b/research/p104-a2-cleanup-composition/verify.py @@ -0,0 +1,120 @@ +"""Replay the complete composed P104 supplier. Ali Romman with OpenAI Codex. + +The native, controller, interval, compiler and outer engines retain their +source authors and assumptions. Apache-2.0. +""" +import argparse +from copy import deepcopy +import gzip +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import construct + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def reject(action): + try: + action() + except ValueError as e: + return str(e) + raise ValueError('Invalid control accepted') + + +def run(quick=False): + pins = json.loads((HERE/'SOURCE-CONTEXT.json').read_text()) + for p in pins: + raw = (HERE/p['local']).read_bytes() + need(len(raw) == p['size'] and sha256(raw).hexdigest() == p['sha256'], 'Exact source: '+p['local']) + neutral = HERE/'inputs/pr5644' + S = load(neutral/'sources.py', 'composed_sources') + cleanup = load(neutral/'construct.py', 'retained_cleanup') + with S.sources() as (parent, root): + L = load(parent/'local.py', 'local') + source = L.read(parent/'WORD.json.gz') + witnesses = L.read(neutral/'WITNESS.json') + word, changes, local, neutral_word, old = construct.compose(source, witnesses, cleanup, L) + need(neutral_word == L.read(neutral/'WORD.json.gz'), 'Exact regenerated PR5644 word') + need(construct.a2(source,L)['program'] == L.read(HERE/'inputs/pr5643/WORD.json.gz')['program'], 'Exact regenerated PR5643 word') + need(local['real_scalar_allowance'] == 220220, 'Complete ordinary scalar charge') + need((local['public_inputs'],local['owned_fields'],local['owned_lifetimes'],local['peak_owned_fields']) == (743,9,11,2), 'Complete input and owned inventory') + print('PASS both source constructions and both composition orders', flush=True) + if quick: + print('PASS_P104_A2_CLEANUP_QUICK', flush=True) + return None, word + columns = L.reverse_columns(word) + native = L.native(word) + C = load(root/'research/p104-productive-controller/caller.py', 'composition_caller') + caller = C.construct() + need(caller == L.read(root/'research/p104-productive-controller/CONTROLLER.json'), 'Exact retained caller') + physical = C.physical(caller, word) + print('PASS all columns, native phases and complete physical caller', flush=True) + original = (neutral/'pricing.py').read_text() + for before, after in json.loads((HERE/'PRICING-EDITS.json').read_text()): + need(original.count(before) == 1, 'Unique declared price edit') + original = original.replace(before, after) + need(original == (HERE/'pricing.py').read_text(), 'Only declared price changes') + P = load(HERE/'pricing.py', 'composition_price') + price = P.run(local,native,caller,physical) + print('PASS two exact moment engines, compiler and all outer predicates', price['raw_root_interval'], flush=True) + controls = C.controls(caller) + bad = deepcopy(word) + bad['program'].remove(['ADD',340,715,'-4',396]) + controls['missing_A2_correction'] = reject(lambda:L.replay(bad)) + bad = deepcopy(word) + bad['program'].pop(0) + controls['missing_helper_preparation'] = reject(lambda:L.replay(bad)) + bad = deepcopy(word) + bad['program'].pop(max(i for i,e in enumerate(bad['program']) if e[0] == 'CLEAR')) + controls['missing_owned_clear'] = reject(lambda:L.replay(bad)) + bad = deepcopy(local) + bad['paid'][1] -= 1 + controls['unfunded_query'] = reject(lambda:P.assemble(bad,native,caller,physical)) + bad = deepcopy(local) + bad['helpers'][1] += 1 + controls['extra_target'] = reject(lambda:P.assemble(bad,native,caller,physical)) + return P.encode(dict(status='PASS_P104_A2_CLEANUP_KAPPA_00310644469', + source_heads={str(p['pr']):p['commit'] for p in pins}, + changes=changes, local=local, separate_columns=columns, + native=native, physical=physical, complete_cost=price, controls=controls)),word + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + parser.add_argument('--quick', action='store_true') + args = parser.parse_args() + result, word = run(args.quick) + if args.quick: + return + for name, value in [('RESULT.json',result),('WORD.json.gz',word)]: + path = HERE/name + if args.write: + raw = (json.dumps(value,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) == value, 'Exact saved artifact: '+name) + print(result['status'],flush=True) + + +if __name__ == '__main__': + main()