diff --git a/research/geometric-tail-compiler/LICENSE b/research/geometric-tail-compiler/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/geometric-tail-compiler/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/geometric-tail-compiler/README.md b/research/geometric-tail-compiler/README.md new file mode 100644 index 0000000000..be78602c85 --- /dev/null +++ b/research/geometric-tail-compiler/README.md @@ -0,0 +1,85 @@ +# Direct geometric tails and adaptive compiler parameters + +**Conditional κ = 0.0030266747680744.** This is a tiny increase of **3.0744 × 10⁻¹²** over PR #5387’s 0.003026674765 on exactly the same complete eight-relation paid/target profile. The useful companion result is a smaller finite compiler at the unchanged predecessor saving: tensor power 1024 → 505, logarithmic power 1000 → 484, and the sufficient exponent H in N = 2^H decreases by a factor of about 2.105. This is not a practical runtime speedup or a new native mechanism. + +The new endpoint and smaller matched compiler are two distinct parameter choices. At the higher κ, the much smaller outer gap requires a larger threshold; we do not claim simultaneous improvement of both κ and H relative to the predecessor’s original parameters. + +## Positive sufficient theorem + +Take a fully charged finite provider with target moment T_t, paid moment P_t, B productive fields and raw ambient rank m. Let t = 1 − C, choose integer cutoffs 1 < c < b < m, and u ≥ C. Suppose rational envelopes satisfy + +`α = P_t/T_t ≤ 1 − ρ`, `γ = P_(t+u)/(c^u T_t) ≤ g`, `δ = Bb/(c^C T_t) ≤ d`, + +where 0 < ρ, g, d < 1. The paid product/completion/splitting theorem from zxv’s `higher-moment-strictification` bounds the complete normalized paid moment by `α^v + 2 γ^v + 2 δ^v`. Therefore the sufficient bound + +`B(v) = 1/(1 + vρ) + 2 g^v + 2 d^v < 1` + +certifies a strict completed moment advantage, with every split and completion charged. + +Proof: `(1 − ρ)^(-v) ≥ (1 + ρ)^v ≥ 1 + vρ`, hence `α^v ≤ 1/(1 + vρ)`. Bound the other two terms by their rational envelopes. Each term of B(v) decreases with v, and B(v) tends to zero, so a finite integer v exists. Doubling followed by binary search returns the least positive integer satisfying this sufficient bound. This is not a minimum over actual native constructions, and no geometric-tail term is discarded. + +For a separated unit, let θ be a valid rational exit exponent and let rational η_lower and initial_upper bound `(1−C)m^(-C)` from below and `m^C` from above. Since θ^p tends to zero and 2^p tends to infinity, a finite positive integer p satisfies `θ^p < η_lower` and `2^p > initial_upper`. The same doubling/binary method finds the least admissible p for these supplied bounds. Under the retained shifted-exit hypothesis, zxv’s logarithmic majorant then gives `L(n) ≤ n^(1−C)(1 + log₂ n)^p` for all positive integer n. + +For any positive rational saving gap ε, choose s = ceil(1/ε), then an integer j with `(sj + 1)^p < 2^j`, and set H = sj. Such a j exists because exponential growth dominates polynomial growth. Since εH ≥ j, `(H+1)^p < 2^(εH)`. The function `εh log(2) − p log(1+h)` is strictly convex, vanishes at zero and is positive at H, so it is increasing and positive thereafter. Consequently the logarithmic factor is absorbed for all n ≥ 2^H. This proves a sufficient finite uniform threshold, not a minimum native program. + +`strictify.py` implements these three rational searches without floating-point decisions. The completion theorem and arbitrary-positive-logarithm majorant are inherited from zxv, not newly invented here. The contribution is the reusable parameter selection and its fully checked application to this frozen supplier. + +## New conditional endpoint + +The complete inventory remains 64,148 paid jobs, 10,800 productive fields and rank surplus 752. The new point uses: + +| Parameter | Exact choice | +|---|---:| +| Claimed κ | 0.0030266747680744 | +| Tested saving C | 0.0030266747680745 | +| Reserve ρ | 10⁻¹⁷ | +| Gamma envelope g | 957/1000 | +| Delta envelope d | 952/1000 | +| Tensor power v | 757 | +| Cutoff / completion floor | 20 / 21 | +| Tail offset u | 1/5 | +| Exit exponent θ | 63/64 | +| Logarithmic power p | 725 | +| Outer gap | 1/70,000,000,000,000,000 | +| H in N = 2^H | 3,634,890,000,000,000,000,000 | + +The fixed-profile root is enclosed by `(0.0030266747680745498, 0.0030266747680745499)`. The compiler saving is strictly below that interval. Two rational interval engines check the full moments. Every source-exit, complement-capacity and initial-range inequality is checked at the new v and p. All 54 strict and four functional outer predicates pass. The old coarse `4/2^32` tail allowance fails at the new power/reserve; the direct geometric tail bound succeeds. The preceding v and p fail their respective sufficient tests. + +All native costs remain charged. The scalar allowance is 158,776, route allowance 4,834,000 and complete raw nonrecursive bound 181,098,496 < 10⁹. The eight private helper pivots and eight simultaneously live snapshots are retained, as are their lost productive targets. The enormous expanded product/compiler word is specified algorithmically and not materialized. + +## Matched comparison at the previous κ + +Keep PR #5387’s κ = 0.003026674765, tested saving 0.003026674766 and reserve 10⁻¹² unchanged. Fresh moment/tail/capacity checks with the same rational envelopes give: + +| Quantity | PR #5387 | Direct tails | +|---|---:|---:| +| Tensor power | 1024 | 505 | +| Logarithmic power | 1000 | 484 | +| H in N = 2^H | 409,549,000,000,000,000 | 194,586,000,000,000,000 | + +The H reduction factor is approximately 2.10472. Since the threshold is 2^H, this is a reduction in the exponent of a sufficient threshold, not a measured speedup. No paid-profile or asymptotic κ gain is attributed to this matched comparison. + +## Source binding and verification + +```sh +python3 -B scripts/research_package.py --package research/geometric-tail-compiler +python3 -B scripts/check_research_commit.py --package research/geometric-tail-compiler +``` + +Python 3.12, standard library only. Both registered normal and optimized runs are read-only. `verify.py --write` regenerates only this package’s RESULT.json after checking the frozen native word. VENDOR.json pins exact retained files from PR #5387 commit `b1ab650d36f59e5be682a813145b7c67e219e341`; no pending Git object is required for replay. SOURCES.json pins every external runtime input on canonical main. Vendor files and all predecessors remain unchanged. + +Fresh checks reconstruct the native word, all 632 forward persistent inputs, all 624 retained backward inputs, 17 owned entry fields, eight independent relations, sixteen source identities, frame/paid-rank constraints and all helper returns. They check the p16 Laurent controller and entire inventory, both interval engines, completion, finite compiler, outer predicates and predecessor-matched comparison. Invalid/inexact parameter inputs, wrong pivot signs, wrong snapshot/gauge, missing clears, corrupted ranks and invalid outer claims are rejected. The coarse-tail failure and preceding-power failures guard the parameter change. Engines are adapted from the retained predecessor implementations; no independently authored full native interpreter is claimed. + +Scope remains conditional on the selected source’s native/all-size, whole-job, permitted-erasure, precision/tape, analytic, prime and exact-recovery contracts. Source phase evidence and the stronger ordinary BIT supplier are authenticated and reused. Physical tape/precision execution, full phase lowering, analytic decomposition, Lean/kernel verification, expanded word materialization, hosted CI and independent human acceptance are not supplied. Selected-result metadata is unchanged. Full-history ancestry checking is not claimed for the shallow checkout. + +## Open next questions + +Recent PRs #5385 and #5388 were inspected: neither claims a completed higher bound. The former repairs a reference transcription; the latter supplies funded helper queries but leaves caller integration open. Bounded saved-row-span, exact-cache and controller-parameter screens found no better paid profile in their tested families. They are discovery checks, not global impossibility claims, and are not used as proof evidence for this positive result. Discussion and literature coverage are incomplete. + +The next useful application is another fully charged provider profile: supply exact rational envelopes to strictify.py, then recheck every compiler and outer condition. There is no guaranteed improvement for arbitrary suppliers. TASK.json records the concrete first step and remaining admission obligation. + +## Attribution + +zxv: higher-moment paid-tail theorem, logarithmic majorant and productive-helper/compiler machinery. Ali Romman: PR #5377’s helper-relation implementation and PR #5383’s eight-relation construction. Cao Yifan: PR #4610 native source, phase evidence and prior compiler tightening. Cinna Davis: PR #4470 p16 controller/helper lineage. Chris R: independent PR #5241 source admission and PR #5384 single-relation audit, neither of which automatically admits this endpoint. Jacob Alan Sussman: mixed-target recursion. Dugongue: PR #5387’s frozen compiler certificate and this adaptive direct-tail application. ToikY and all retained Clifford, native, BIT, precision and analytic contributors retain source credit. This does not claim novelty for the geometric-tail theorem, binary search or logarithmic majorants. + +Prepared by Dugongue with substantial OpenAI Codex assistance, solo. Apache-2.0. diff --git a/research/geometric-tail-compiler/RESULT.json b/research/geometric-tail-compiler/RESULT.json new file mode 100644 index 0000000000..425ae0a08e --- /dev/null +++ b/research/geometric-tail-compiler/RESULT.json @@ -0,0 +1,444 @@ +{ + "arithmetic": { + "compiler": { + "H": 3634890000000000000000, + "N": "2^3634890000000000000000", + "eta": { + "lower": "0.000011131988139561317902921511", + "upper": "0.000011131988139561317902921512" + }, + "gap": "1/70000000000000000", + "integer_test_exponent": 51927, + "logarithm_power": 725, + "theta": "63/64", + "uniform_saving": "105933616882607/35000000000000000", + "word_materialized": false + }, + "completion_reserve": "1/100000000000000000", + "fixed_profile_ceiling": { + "decreasing_through": "1/20", + "derivative_upper": { + "lower": "-195473.450610684184815935477074865515", + "upper": "-195473.450610684184815935477074865514" + }, + "remaining_interval_moment_upper": { + "lower": "-6820.155255095433991980526890420873", + "upper": "-6820.155255095433991980526890420872" + } + }, + "full_backward": 16, + "full_forward": 2, + "gain_over_PR4610": "6123710093/1250000000000000", + "gain_over_PR5383": "18460093/1250000000000000", + "gain_over_PR5387": "3843/1250000000000000", + "kappa": "3783343460093/1250000000000000", + "kappa_decimal": ".0030266747680744", + "margin_at_previous_kappa": { + "lower": "1.209169472215494738857340795394", + "upper": "1.209169472215494738857340795395" + }, + "margin_at_previous_root_upper": { + "lower": "1.209152002019805295008574084544", + "upper": "1.209152002019805295008574084545" + }, + "matched_PR5387": { + "complete_normalized_upper": "100000000049129185054410465819067091525726487025392596349248734645227297350087063090090837556931955462501705552063413257501741726359123488647780300337926778712949269541593733562603669775821816948798643407065532640295641406924290816174731065248579484872475443679809527813982052850395528171724097598050038254832085568872963016639608883130507882594263650828962803239255966163308945609254799654762669715941417797672274911953109783181710553476084564636189515471817732274271714858647170484050530589280526746939216693322024242198609852392587936916645152954243722047947534309313870290543841322000536508992801935071547956776523941149382196659934428953560628372523609200325835113107103462066574401362802706931100063347625813544281347686582351270343888298571675483900794173243350972359777662665491744206374111389902850669436002164440903987272758130878987137080258162904352955130357010817148703920179734365821975259478483544793733430196499608089587766177775602983621467265599247625457777657463389126427785137727001594153287770444746206545868219632704561614031161476139402625676473808720702339185923876282864073598446814429440078422143324502602798187678336083716432122963302771019920018381350878657146973835144829406230680317595671416015586250185405679040804000340120157386458282488611277731939344456901719155900230534042277146221115948292712484865598932803723757917119646764233796898225965797475294440406784769776715476309851974278970860282589963470386490600023235407984959489073535934166857213615771725159206402721762935597338240369941489/100000000050500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "j": 27798, + "kappa": "605334953/200000000000", + "new_H": 194586000000000000, + "new_logarithm_power": 484, + "new_power": 505, + "old_H": 409549000000000000, + "old_logarithm_power": 1000, + "old_power": 1024, + "tested": "1513337383/500000000000" + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unearned_helper_credit": "Rejected by the independent complete census", + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "additional_private_slots": 8, + "local_routes": 4834000, + "local_scalar": 158776, + "owned_slots_backward": 17, + "raw_budget": 1000000000, + "raw_scalar_upper": 181098496 + }, + "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": "17429999999999999253/17500000000000000000", + "fixed_halo_explicit_metadata_branch": "1347500000000000001/17500000000000000", + "new_BIT_row_stock_sublinear_in_active_group": "69789999999999997009/70000000000000000000", + "new_semantic_group_guard": "3/70000000000000000" + }, + "margins": { + "boundary_algebraic_matrix": "14830706363564839788132766234789/4900000000000000000000000000000000", + "fused_gaussian": "14830706363564839364398298704367/4900000000000000000000000000000000", + "global_coordinate_router": "52966808441303/17500000000000000", + "group_bit_router": "3707676590891227341099574676091/1225000000000000000000000000000000", + "group_scans": "34999999999999999/35000000000000000", + "main_transform": "14830706363564769788132766234789/4900000000000000000000000000000000", + "microbox_face_corrections": "1347500000000000001/17500000000000000", + "polynomial_products": "69999999999999999/70000000000000000", + "sparse_union_movement": "2005455706363564839788132766234789/4900000000000000000000000000000000" + }, + "parameters": { + "a": "52966808441303/17500000000000000", + "b": "211867233765213/70000000000000000", + "beta": "69999999999999997/70000000000000000", + "bit_saving": "17/5000", + "cap_xi": "4455455706363564769788132766234789/4900000000000000000000000000000000", + "complex_uniform_saving": "105933616882607/35000000000000000", + "d": "1/70000000000000000", + "epsilon": "69999999999999999/70000000000000000", + "kappa": "3783343460093/1250000000000000", + "lambda_": "19939466504638511/20000000000000000", + "lambda_prime": "69788132766234789/70000000000000000", + "layout": "1/70000000000000000", + "q": "211867233765211/70000000000000000", + "r0": "1/700000000000000000", + "stop": "1/70000000000000000", + "tested_saving": "6053349536149/2000000000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "6533191558697/17500000000000000", + "actual_logarithmic_gamma_guard": "1/70000000000000000", + "actual_logarithmic_group_guard": "444544293636435335211867233765211/2450000000000000000000000000000000", + "alpha_logarithm_absorption": "1/700000000000000000", + "boundary_algebraic_matrix_above_kappa": "279788132766234789/4900000000000000000000000000000000", + "cap_above_band": "2005455706363564769788132766234789/4900000000000000000000000000000000", + "cap_below_cell": "444544293636435160211867233765211/4900000000000000000000000000000000", + "cap_below_phase_cell_power": "5344544293636435230211867233765211/4900000000000000000000000000000000", + "complex_above_effective": "1/70000000000000000", + "complex_below_one_over_32": "1975632766234787/70000000000000000", + "complex_endpoint": "1/35000000000000000", + "epsilon_below_one": "1/70000000000000000", + "epsilon_positive": "69999999999999999/70000000000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "279364398298704367/4900000000000000000000000000000000", + "gaussian_above_main": "34788132766234789/2450000000000000000000000000000000", + "global_coordinate_router_above_kappa": "1/17500000000000000", + "global_gamma_power_slack": "9/700000000000000000", + "group_below_dimension": "1/35000000000000000", + "group_bit_router_above_kappa": "87341099574676091/1225000000000000000000000000000000", + "group_gauge_power_slack": "444544293636435331711867233765211/2450000000000000000000000000000000", + "group_key_fits_record": "1/35000000000000000", + "group_positive": "69999999999999997/70000000000000000", + "group_scans_above_kappa": "6978813276623479/7000000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "647852174437618148631/500000000000000000000000", + "lambda_above_internal": "1/140000000000000000", + "lambda_above_sigma": "3/140000000000000000", + "lambda_above_tau": "1/140000000000000000", + "lambda_prime_above_lambda": "1/140000000000000000", + "lambda_prime_above_leaf": "139788132766234787/4900000000000000000000000000000000", + "leaf_saving_above_effective": "69788132766234787/4900000000000000000000000000000000", + "main_transform_above_kappa": "209788132766234789/4900000000000000000000000000000000", + "membership_arithmetic_fits_record": "1/70000000000000000", + "microbox_face_corrections_above_kappa": "1347447033191558699/17500000000000000", + "microbox_halo_volume": "5530000000000000003/70000000000000000", + "new_complex_uniform_saving_above_b": "1/70000000000000000", + "new_semantic_guard_with_C1_one": "1/70000000000000000", + "polynomial_products_above_kappa": "69788132766234791/70000000000000000", + "positive_layout_slack": "1/70000000000000000", + "q_below_effective": "1/70000000000000000", + "q_below_internal": "1/70000000000000000", + "q_below_leaf": "139788132766234787/4900000000000000000000000000000000", + "q_positive": "211867233765211/70000000000000000", + "short_record_fallback": "69788132766234787/70000000000000000", + "source_axis_superpolynomial": "1/70000000000000000", + "sparse_union_movement_above_kappa": "1990625000000000279788132766234789/4900000000000000000000000000000000", + "stop_below_one": "69999999999999999/70000000000000000", + "stop_positive": "1/70000000000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/70000000000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/70000000000000000", + "union_tag_work_per_visit_fits_record": "3/70000000000000000" + } + }, + "paid": { + "1": 41170, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 16 + }, + "paid_calls": 64148, + "productive_fields": 10800, + "query_shears": 15, + "rank_mass_surplus": 752, + "raw_headroom": [ + "7249/50000000000000000000", + "14499/100000000000000000000" + ], + "raw_root_interval": [ + "151333738403727249/50000000000000000000", + "302667476807454499/100000000000000000000" + ], + "strictification": { + "alpha": { + "lower": "0.999999999999999952991079154847", + "upper": "0.999999999999999952991079154848" + }, + "cutoff": 20, + "delta": { + "lower": "0.951652475843147164892996334630", + "upper": "0.951652475843147164892996334631" + }, + "delta_envelope": "119/125", + "floor": 21, + "gamma": { + "lower": "0.956968566611070131231895728694", + "upper": "0.956968566611070131231895728695" + }, + "gamma_envelope": "957/1000", + "normalized_paid_upper": "50000000000000361821137132795443427103358237119851673592428591063099387112112002669340810037943170169599953837251296491416005090706696068468813838497084771274677811884812319200814107195163701782973146232134937155698574878277084848594702812296176370612197353952996334885079599015944626051605451852523891980905177716022543548179984732812940854922538808584175910336076176499422839227452825936721945360245220531768759422967215292272646408217191773218514921239455086870724736536667402277447075202093603758553518264832774056813305357415462494160014854299522780557073573060561143676165166900423738098183521554188148415421127187645563278517337696324164976202862347289154424399725796233012365347349380888508450287023939907186362125301390676529925560497588921089316900380452597963391998283942030123807355270736513700701745416207701395850740775352465772250197206722931819329744331999479095411972993424048317453420803751496699740641874584316957217219342429903193532358669334192624889512148398531452615495349922564923589854175271943333514269141804687728212462158345768980508391699362634588474042375709369173674496316013862648218886369312966246003537964647654804528322268789282600320863459355769396838929499090492875435491403386180825158033416905642494596398493016081291218657031069630533339747454459556874607287374393400199972235921824354420605643111913760566037178949029647023875607618468879861196073218312749882177571741425525396572791884779875960468025905916243499189911824418143622882925248764565932200067177197697698885911330454251033758176899236942741115968631232608763052904814151005951443744244616491224943449054694103912097167016360283990527748351920766123407859937508619426268297357413774485452037536623154962925386402116850769526903064226989910811743960123645215630076177736842708714810977330806733890108467504744966189525201362167924245355986848275455058697217632898902640466581825195581173805684507585699637379737391079853614612136903685728942111618309914132795194833149191967573046129568058163582808651480721088332417181893650551772864079142358618371410134395771110294829760105006706304678296274357164656958708721023419560908620942068574281443251211919712015735931089327329640347992145696303861344312887341233953098441282203358572229776483916454770824068514883931537336481246205952007153/50000000000000378500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "power": 757, + "reserve": "1/100000000000000000", + "tail_offset": "1/5", + "tested": "6053349536149/2000000000000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5740 + } + }, + "candidate_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 318 + }, + "independent_owned_entry_columns": 17, + "independent_persistent_columns": 624, + "max_denominator": 64, + "max_formal_prefix_l1": "163", + "owned_outputs_zero": true, + "paid": { + "1": 2193, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "real_scalar_allowance": 158776, + "zero_identities": 8 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "independent_source_identities": [ + { + "center": 11332, + "center_factor": "1/4", + "site": 0, + "zero_factor": "-1/4" + }, + { + "center": 11358, + "center_factor": "1/4", + "site": 1, + "zero_factor": "-1/4" + }, + { + "center": 11384, + "center_factor": "1/4", + "site": 2, + "zero_factor": "-1/4" + }, + { + "center": 11410, + "center_factor": "-1/4", + "site": 3, + "zero_factor": "1/4" + }, + { + "center": 11436, + "center_factor": "1/4", + "site": 4, + "zero_factor": "-1/4" + }, + { + "center": 11462, + "center_factor": "-1/4", + "site": 5, + "zero_factor": "1/4" + }, + { + "center": 11488, + "center_factor": "1/4", + "site": 6, + "zero_factor": "-1/4" + }, + { + "center": 11514, + "center_factor": "-1/4", + "site": 7, + "zero_factor": "1/4" + } + ], + "native_negative_controls": { + "missing_owned_input_clear": "Every independent main/helper endpoint: 0", + "uncleared_owned_output": "Every owned entry column is erased at return", + "under_or_overstated_paid_rank": "Exact paid rank and frame", + "wrong_copy_gauge": "Exact scalar destination frame", + "wrong_prepared_pivot_225": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_227": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_229": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_230": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_241": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_245": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_257": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_261": "Every independent main/helper endpoint: 1", + "wrong_relation_sign": "Every independent main/helper endpoint: 0", + "wrong_snapshot_source": "Zero identity requires an identically zero full row", + "wrong_zero_input_frame": "Zero identity requires an identically zero full row" + }, + "phase_inheritance": { + "absolute_phase_receipt_reused": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "all_retained_paid_events_and_warps_from_source": true, + "new_gaussian_operators": 0, + "new_native_maps": 0, + "new_operations": "Same-frame COPY, owned CLEAR/ADD, and physical identity on a proved zero row.", + "source_amplitudes_and_phase_lowering_freshly_replayed": false + }, + "relation_basis": { + "dyadic": true, + "pivots": [ + 225, + 227, + 229, + 230, + 241, + 245, + 257, + 261 + ], + "rank": 8 + }, + "scope": "Exact finite word, full all-column endpoints, ownership, p16 bill and compiler arithmetic. Retains source native phase, allowed owned erasure, mixed-target all-size, analytic, precision, tape, prime and exact-recovery contracts. No selected-frontier update.", + "source_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158168, + "zero_identities": 0 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_CONDITIONAL_KAPPA_0030266747680744_GEOMETRIC_TAILS", + "word_payload_sha256": "9aa0d7112b4e13f1aa13a93dab0af6f4435ffe99b842aad841685becdafee492" +} diff --git a/research/geometric-tail-compiler/SOURCES.json b/research/geometric-tail-compiler/SOURCES.json new file mode 100644 index 0000000000..24495c731c --- /dev/null +++ b/research/geometric-tail-compiler/SOURCES.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/free-word-tensor-lift-audit/PROOF.md", + "usage": "provenance", + "git_blob": "69c337a7704ce589798269ab4b8606189c070c4e", + "sha256": "cc8ad3698a673fb225419a3636a39aa99a66c7a0676f12e329b1e76564fa1459" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/joint-helper-lattice/CONTROLLER.json", + "usage": "input", + "git_blob": "49a2f0675819f9deeea27ed77be2c2b6ff2e87e5", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f" + }, + { + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/kappa-interface-round2-20261022/price_profile.py", + "usage": "provenance", + "git_blob": "1d93e43d1cb888d128c2faa2be83a96d85b84295", + "sha256": "adde619968d3ac37147d239e25145b28150650e9ce0f76035f680f22589adcbb" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "usage": "provenance", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "usage": "input", + "git_blob": "ac77b78547d6dbf2e6bd102e1047c5b16c1bca88", + "sha256": "6eae66ed3cfa8a1533e89b9660a57276908e6646640a12f8b1e3489f4ea1354b" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "usage": "input", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/query-thinned-controllers/RESULT.json", + "usage": "input", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "provenance", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + } + ] +} diff --git a/research/geometric-tail-compiler/TASK.json b/research/geometric-tail-compiler/TASK.json new file mode 100644 index 0000000000..b8c975b31f --- /dev/null +++ b/research/geometric-tail-compiler/TASK.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Apply direct charged geometric tails and adaptive tensor/logarithm powers to the frozen eight-relation supplier: conditional kappa 0.0030266747680744 and a smaller matched compiler at the PR5387 exponent.", + "scope_change_reason": "Saved-row, cache and controller screens found no paid-profile gain. The achieved result tightens the sufficient completion/compiler construction, with exact inherited costs and no new native mechanism.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19153737", + "budget_minutes": 60, + "stop_rule": "Publish one exact complete-profile kappa improvement after native, ownership, phase-inheritance, compiler and cold-export checks.", + "outcome": "partial", + "evidence": "Frozen native replay, all-column identities, complete profile/controller, two interval engines, adaptive rational completion parameters, exact finite threshold and outer predicates, matched old-exponent comparison.", + "author": "Dugongue", + "ai_assistance": "Substantial OpenAI Codex assistance, solo; no subagents.", + "open_questions": [ + { + "question": "Can the adaptive completion certificate be applied to other fully charged provider profiles?", + "why_it_matters": "It can reduce finite template sizes without requiring a new native circuit or weakening productive-target costs.", + "first_step": "Supply exact rational alpha/gamma/delta envelopes for one admitted complete profile, then rerun strictify.py and all changed compiler/outer predicates.", + "blocked_by": "No guarantee of improvement for an arbitrary provider; caller/native admission remains separate." + } + ], + "coordination": { + "coverage": "Recent updated PRs through #5388; source-bound reading of #5385/#5388 and prior all-open search retained in the prior campaign. Incomplete Discussion coverage.", + "scope": "Completion/compiler parameters on #5383/#5387 bill; no claim to the funded query interface or forward-transpose work." + } +} diff --git a/research/geometric-tail-compiler/VENDOR.json b/research/geometric-tail-compiler/VENDOR.json new file mode 100644 index 0000000000..a8331144c6 --- /dev/null +++ b/research/geometric-tail-compiler/VENDOR.json @@ -0,0 +1,13 @@ +{ + "source_pr": 5387, + "commit": "b1ab650d36f59e5be682a813145b7c67e219e341", + "source_directory": "research/eight-owned-relations", + "files": { + "native.py": "21e616b991fdc3af414e5e390e9eb6bb93ba39a560e235d324f4bb303148c1e8", + "RELATIONS.json": "bc9ba05595497f399da5e5a548b2d2c83696e539fa1257ab7e2cb49d438cd9dd", + "WORD.json.gz": "6412632c28e265597fb088087048091d81c19500fb28a0c9c9d2a48f61b8665b", + "SOURCES.json": "3b1536861c5b6990966ad5107f3a619f5d9da548f3c4eaa454ec32341e640dd3", + "PREDECESSOR-5383.json": "d6a99bd75c6b7a2146b0fc4cfa038890aaf1d4adcdef42d767fdb40b687e61aa", + "RESULT.json": "34ad456c1f98f7f8c361d63539ef26d75dad8ffb3444edf29652372acabf1aaf" + } +} diff --git a/research/geometric-tail-compiler/VERIFY.json b/research/geometric-tail-compiler/VERIFY.json new file mode 100644 index 0000000000..8c497c063e --- /dev/null +++ b/research/geometric-tail-compiler/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/higher-moment-strictification/verify.py", + "research/joint-helper-lattice/CONTROLLER.json", + "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/query-thinned-controllers/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Fresh frozen native replay, complete invoice, direct geometric tails, adaptive tensor/logarithm powers, finite threshold, matched compiler comparison and all outer predicates." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "The same checks remain active with Python assertions disabled." + } + ] +} diff --git a/research/geometric-tail-compiler/price.py b/research/geometric-tail-compiler/price.py new file mode 100644 index 0000000000..954c6b4535 --- /dev/null +++ b/research/geometric-tail-compiler/price.py @@ -0,0 +1,211 @@ +"""Direct charged geometric tails for the frozen eight-relation p16 bill. + +The interval and compiler proof follows Cao Yifan's PR4610 pricing, Cinna +Davis's PR4470 controller, zxv's completion and logarithmic majorant, and +Jacob Alan Sussman's mixed-target recursion. Apache-2.0. +Derived from Ali Romman PR5377; eight-relation assembly by Dugongue, +with substantial OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from strictify import completed_upper, tensor_power, logarithm_power, finite_threshold +from native import ROOT, read, load, need, encode, OLD_PAID, OLD_HELPERS + +KAPPA = Q('.0030266747680744') +TESTED = Q('.0030266747680745') +PREVIOUS = Q('.0030217758') +OLD_ROOT_UPPER = Q('.00302177587078') + + +def controller(): + """Check the literal p16 word and both rational boundary programs.""" + word = read(ROOT / 'research/joint-helper-lattice/CONTROLLER.json') + need((word['kind'], word['pairs'], word['prefix_pairs'], word['ambient_rank']) == ('complex', 16, 7, 145), 'Source p16/a7 controller') + zero = (0,) * 34 + def plus(dst, src, q): + for k, v in src.items(): + value = dst.get(k, Q(0)) + q * v + if value: dst[k] = value + else: dst.pop(k, None) + def shifted(row, term, sign=1): + return [{tuple(a + b for a, b in zip(k, term)): sign * v for k, v in cell.items()} for cell in row] + for side in ('left', 'right'): + matrix = [[Q(i == j) for j in range(32)] for i in range(32)] + for e in word['boundaries'][side + '_program']: + if e[0] == 'SWAP': matrix[e[1]], matrix[e[2]] = matrix[e[2]], matrix[e[1]] + elif e[0] == 'SCALE': matrix[e[1]] = [Q(e[2]) * x for x in matrix[e[1]]] + else: + need(e[0] == 'ADD', 'Boundary scalar opcode') + matrix[e[1]] = [x + Q(e[3]) * y for x, y in zip(matrix[e[1]], matrix[e[2]])] + need(matrix == [[Q(x) for x in row] for row in word['boundaries'][side]], 'Exact scalar boundary program') + rows = [[{zero: Q(x)} if Q(x) else {} for x in row] for row in word['boundaries']['right']] + for e in word['physical_events']: + if e[0] in ('LOCAL', 'QUERY_SHEAR'): + _, stage, pair, back = e + x, y = 2 * pair, 2 * pair + 1 + if back: x, y = y, x + term = (1 if back else -1,) + (0,) * 33 + for dst, src in zip(rows[y], shifted(rows[x], term)): + plus(dst, src, Q(-1 if back else 1)) + if e[0] == 'LOCAL': + term = (0,) + tuple(int(s == stage) for s in range(33)) + for r in (x, y): rows[r] = shifted(rows[r], term) + elif e[0] == 'IDLE': + term = (0,) + tuple(int(s in e[2]) for s in range(33)) + for r in (2 * e[1], 2 * e[1] + 1): rows[r] = shifted(rows[r], term) + elif e[0] == 'ADD': + for dst, src in zip(rows[e[1]], rows[e[2]]): plus(dst, src, Q(e[3])) + else: + need(e[0] in ('SWAP', 'SIGNED_SWAP'), 'Controller physical opcode') + rows[e[1]], rows[e[2]] = rows[e[2]], shifted(rows[e[1]], zero, -1 if e[0] == 'SIGNED_SWAP' else 1) + out = [[{} for _ in range(32)] for _ in range(32)] + for i, row in enumerate(word['boundaries']['left']): + for k, q in enumerate(row): + if Q(q): + for j in range(32): plus(out[i][j], rows[k][j], Q(q)) + expected = [[{tuple(word['diagonal'][i]): Q(1)} if i == j else {} for j in range(32)] for i in range(32)] + need(out == expected, 'All p16 Laurent coefficients, central signs and boundary factors') + return word + + +def assemble(native, word): + T, P = Counter(), Counter() + orientations = Counter(); thin = 0 + for e in word['physical_events']: + if e[0] == 'LOCAL': + direction = 'backward' if e[3] else 'forward' + orientations[direction] += 1 + T.update(native[direction]['helpers']); P.update(native[direction]['paid']) + elif e[0] == 'QUERY_SHEAR': thin += 1; P[1] += 112 + elif e[0] == 'IDLE': P[8 * len(e[2])] += 224 + main = Counter() + for term in word['diagonal']: + need(term[0] in (-1, 1) and all(x in (0, 1) for x in term[1:]), 'Whole Gaussian main target') + main[1 + 8 * sum(term[1:])] += 112 + T.update(main) + need(orientations == {'backward': 16, 'forward': 2} and thin == 15, 'Every actual call orientation') + # This second census uses the source invoice and the directional profile deltas. + check_T = Counter({int(r): n for r, n in word['invoice']['main'].items()}) + check_T.update({r: 18 * n for r, n in OLD_HELPERS.items()}); check_T[9] -= 128 + check_P = Counter({int(r): n for r, n in word['invoice']['whole_idle'].items()}) + check_P.update({r: 18 * n for r, n in OLD_PAID.items()}); check_P[1] += 1680 - 128; check_P[8] -= 128 + need(T == check_T and P == check_P, 'Independent full invoice substitution') + need(sum(T.values()) == 10800 and sum(P.values()) == 64148, 'Complete productive and paid counts') + need(sum(r * n for r, n in T.items()) - sum(r * n for r, n in P.items()) == 752, 'Unchanged complete rank surplus') + return T, P + + +def run(native): + word = controller(); T, P = assemble(native, word) + from native import HERE + predecessor = read(HERE / 'PREDECESSOR-5383.json') + old = predecessor['arithmetic'] + need(Q(old['kappa']) == Q('.00302666'), 'Pinned concurrent eight-relation bound') + need(T == Counter({int(r):n for r,n in old['targets'].items()}) and P == Counter({int(r):n for r,n in old['paid'].items()}), 'Same complete bill as PR5383') + need(KAPPA > Q(old['kappa']), 'Strict compiler-margin improvement over PR5383') + prior = read(ROOT / 'research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json') + need(Q(prior['kappa']) == PREVIOUS and Q(prior['raw_root_interval'][1]) == OLD_ROOT_UPPER, 'Pinned prior conditional bound and raw crossing') + prior_T = Counter({int(r): n for r, n in prior['targets'].items()}) + prior_P = Counter({int(r): n for r, n in prior['paid'].items()}) + prior_T[9] -= 128; prior_P[1] -= 128; prior_P[8] -= 128 + need(T == prior_T and P == prior_P, 'Complete delta from the final PR4610 bill') + E = load('research/higher-moment-strictification/verify.py', 'owned_relation_intervals') + other = load('research/kappa-rebuild/architecture/mixed_target_probe.py', 'owned_relation_second_intervals') + def margin(c): + t, p = E.moment(T, 1 - c), E.moment(P, 1 - c) + return t[0] - p[1], t[1] - p[0] + need(margin(OLD_ROOT_UPPER)[0] > 0, 'Changed invoice beats the prior raw root upper endpoint') + lo, hi, grid = 302667476807000000, 302667476808000000, 10**20 + while hi - lo > 1: + mid = (lo + hi) // 2 + if margin(Q(mid, grid))[0] > 0: lo = mid + else: hi = mid + root_low, root_high = Q(lo, grid), Q(hi, grid) + need(margin(root_low)[0] > 0 and margin(root_high)[1] < 0, 'Strict rational root enclosure') + need(PREVIOUS < KAPPA < TESTED < root_low, 'New bound and explicit compiler headroom') + # The complete signed profile decreases on [0, .05], and stays negative + # on [.05, 1]. This proves a fixed-profile ceiling, not a circuit ceiling. + signed = {r: T[r] - P[r] for r in T.keys() | P.keys()} + derivative, upper = None, None + for i in range(16): + l, r = Q(i, 320), Q(i + 1, 320); low = Q(0) + for rank, n in signed.items(): + term = E.mul(E.power(rank, 1 - r if n > 0 else 1 - l), E.log_bounds(rank)) + low += n * term[0 if n > 0 else 1] + derivative = low if derivative is None else min(derivative, low) + for i in range(128): + l, r = Q(1, 20) + Q(19 * i, 2560), Q(1, 20) + Q(19 * (i + 1), 2560) + value = sum(n * E.power(rank, 1 - l if n > 0 else 1 - r)[1 if n > 0 else 0] for rank, n in signed.items()) + upper = value if upper is None else max(upper, value) + need(derivative > 0 and upper < 0, 'Fixed-profile ceiling on all 0 < kappa < 1') + t, u, c, b = 1 - TESTED, Q(1, 5), 20, 21 + target, paid = E.moment(T, t), E.moment(P, t) + tl, th = other.moment(T, TESTED); pl, ph = other.moment(P, TESTED) + need(tl > ph and max(tl, target[0]) <= min(th, target[1]) and max(pl, paid[0]) <= min(ph, paid[1]), 'Two exact interval engines agree') + 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 = Q(1, 10**17); g, d = Q(957,1000), Q(952,1000) + v = tensor_power(reserve,g,d) + need(alpha[1] < 1 - reserve and gamma[1] < g and delta[1] < d, 'Original and completion tails charged') + normalized = completed_upper(v,reserve,g,d) + need(normalized<1 and c**64=1, 'Coarse predecessor tail bound fails at this power and reserve') + theta=Q(63,64) + eta=E.scale(E.power(145,-v*TESTED),t) + initial=E.power(145,v*TESTED) + power=logarithm_power(theta,eta[0],initial[1]) + need(2*(20**v)**64 <= (145**v)**63 and eta[0]>theta**power and initial[1]<2**power, 'Complete logarithmic compiler capacity') + gap=(TESTED-KAPPA)/7 + threshold=finite_threshold(gap,power);height=threshold['H'];right=threshold['j'] + need(height>8*v, 'Finite uniform-rank threshold exceeds template scale') + # Matched comparison: retain exactly PR5387's tested and claimed savings. + prev=read(HERE/'RESULT.json')['arithmetic'] + prevC=Q(prev['strictification']['tested']);prevK=Q(prev['kappa']);prevRho=Q(prev['strictification']['reserve']) + prevT=E.moment(T,1-prevC);prevP=E.moment(P,1-prevC) + need(E.divide(prevP,prevT)[1]<1-prevRho, 'Matched comparison paid contraction') + need(E.divide(E.moment(P,1-prevC+u),E.mul(E.power(c,u),prevT))[1]8*cv and cv ordinary > admitted > TESTED and atom < 1 - ordinary, 'Retained stronger BIT admission and stock') + L = load('research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', 'owned_relation_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 = L.ledger(params); outer['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta'] * (1 - atom) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + need(all(x > 0 for key in ('strict_checks', 'functional_checks') for x in outer[key].values()), 'Every outer inequality is strict') + controls = {} + for name, patch in [('old_BIT', {'bit_saving': Q('.0027')}), ('closed_uniform', {'complex_uniform_saving': params['b']}), ('unfunded_endpoint', {'kappa': TESTED}), ('closed_epsilon', {'epsilon': Q(1)})]: + bad = L.ledger(dict(params, **patch)); failed = [k for k, x in bad['strict_checks'].items() if x <= 0] + need(failed, 'Reject outer patch ' + name); controls[name] = failed + bad_native = {d: dict(x) for d, x in native.items()} + bad_native['backward']['helpers'] = OLD_HELPERS + try: assemble(bad_native, word) + except ValueError: controls['unearned_helper_credit'] = 'Rejected by the independent complete census' + else: raise ValueError('Unowned helper credit was accepted') + return encode({'matched_PR5387': comparison, 'gain_over_PR5387':KAPPA-Q('.003026674765'), 'gain_over_PR5383': KAPPA-Q('.00302666'), 'completion_reserve': reserve, 'kappa': KAPPA, 'kappa_decimal': '.0030266747680744', 'gain_over_PR4610': KAPPA - PREVIOUS, + 'raw_root_interval': [root_low, root_high], 'raw_headroom': [root_low - KAPPA, root_high - KAPPA], + 'margin_at_previous_kappa': E.display(margin(PREVIOUS)), + 'margin_at_previous_root_upper': E.display(margin(OLD_ROOT_UPPER)), + 'fixed_profile_ceiling': {'decreasing_through': Q(1, 20), 'derivative_upper': E.display((-derivative,) * 2), 'remaining_interval_moment_upper': E.display((upper,) * 2)}, + 'targets': T, 'paid': P, 'productive_fields': sum(T.values()), 'paid_calls': sum(P.values()), 'rank_mass_surplus': 752, + 'full_backward': 16, 'full_forward': 2, 'query_shears': 15, + 'strictification': {'tested': TESTED, 'power': v, 'cutoff': c, 'floor': b, 'tail_offset': u, 'gamma_envelope':g,'delta_envelope':d,'reserve': reserve, 'alpha': E.display(alpha), 'gamma': E.display(gamma), 'delta': E.display(delta), 'normalized_paid_upper': normalized}, + 'compiler': {'theta': theta, 'logarithm_power': power, 'eta': E.display(eta), 'gap': gap, 'uniform_saving': params['complex_uniform_saving'], 'H': height, 'N': '2^' + str(height), 'integer_test_exponent': right, 'word_materialized': False}, + 'nonrecursive': {'local_scalar': local_scalar, 'local_routes': routes, 'raw_scalar_upper': scalar_upper, 'raw_budget': 10**9, 'additional_private_slots': 8, 'owned_slots_backward': 17}, + 'ordinary_BIT': bit, 'outer': outer, 'negative_controls': controls}) diff --git a/research/geometric-tail-compiler/strictify.py b/research/geometric-tail-compiler/strictify.py new file mode 100644 index 0000000000..81e46752e6 --- /dev/null +++ b/research/geometric-tail-compiler/strictify.py @@ -0,0 +1,53 @@ +"""Exact adaptive completion/compiler parameters. Apache-2.0. +Dugongue with OpenAI Codex assistance; formulas from zxv's higher-moment +strictification and logarithmic majorant, retained by Cao Yifan et al. +""" +from fractions import Fraction as Q + +def need(ok, why): + if not ok: raise ValueError(why) + +def completed_upper(v, reserve, gamma, delta): + need(all(isinstance(x,Q) for x in (reserve,gamma,delta)), 'Exact rational envelopes required') + need(isinstance(v,int) and v>=0, 'Nonnegative integer tensor power') + need(01: + mid=(lo+hi)//2 + if wins(mid):hi=mid + else:lo=mid + need(wins(hi) and not wins(hi-1), 'Least power for this sufficient bound') + return hi + +def logarithm_power(theta, eta_lower, initial_upper): + need(all(isinstance(x,Q) for x in (theta,eta_lower,initial_upper)), 'Exact rational majorant inputs required') + need(00 and initial_upper>0, 'Positive majorant inputs') + def wins(p):return theta**pinitial_upper + lo,hi=0,1 + while not wins(hi):lo,hi=hi,2*hi + while hi-lo>1: + mid=(lo+hi)//2 + if wins(mid):hi=mid + else:lo=mid + need(wins(hi) and (hi==1 or not wins(hi-1)), 'Least admissible positive logarithm power') + return hi + +def finite_threshold(gap, power): + need(isinstance(gap,Q), 'Exact rational gap required') + need(gap>0 and isinstance(power,int) and power>=1, 'Positive compiler gap and integer power') + step=(gap.denominator+gap.numerator-1)//gap.numerator + need(Q(1,step)<=gap, 'Conservative integer gap grid') + def wins(j):return (step*j+1)**power<2**j + lo,hi=0,1 + while not wins(hi):lo,hi=hi,2*hi + while hi-lo>1: + mid=(hi+lo)//2 + if wins(mid):hi=mid + else:lo=mid + need(wins(hi) and (hi==1 or not wins(hi-1)), 'Checked finite integer threshold') + return {'step':step,'j':hi,'H':step*hi} diff --git a/research/geometric-tail-compiler/vendor/PREDECESSOR-5383.json b/research/geometric-tail-compiler/vendor/PREDECESSOR-5383.json new file mode 100644 index 0000000000..b6c9cd0da1 --- /dev/null +++ b/research/geometric-tail-compiler/vendor/PREDECESSOR-5383.json @@ -0,0 +1,961 @@ +{ + "arithmetic": { + "PR5377_raw_root_upper": "75559684087/25000000000000", + "compiler": { + "H": 31385200000000, + "N": "2^31385200000000", + "eta": { + "lower": "0.000000199495867924466542600392", + "upper": "0.000000199495867924466542600393" + }, + "gap": "1/700000000", + "integer_test_exponent": 44836, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "529667/175000000", + "word_materialized": false + }, + "fixed_profile_ceiling": { + "decreasing_through": "1/20", + "derivative_upper": { + "lower": "-195473.450610684184815935477074865515", + "upper": "-195473.450610684184815935477074865514" + }, + "remaining_interval_moment_upper": { + "lower": "-6820.155255095433991980526890420873", + "upper": "-6820.155255095433991980526890420872" + } + }, + "full_backward": 16, + "full_forward": 2, + "gain_over_PR4610": "24421/5000000000", + "gain_over_PR5377": "431/100000000", + "kappa": "151333/50000000", + "kappa_decimal": ".00302666", + "margin_at_previous_kappa": { + "lower": "1.209169472215494738857340795394", + "upper": "1.209169472215494738857340795395" + }, + "margin_at_previous_root_upper": { + "lower": "1.209152002019805295008574084544", + "upper": "1.209152002019805295008574084545" + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unearned_helper_credit": "Rejected by the independent complete census", + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "additional_private_slots": 8, + "local_routes": 4834000, + "local_scalar": 158744, + "owned_slots_backward": 17, + "raw_budget": 1000000000, + "raw_scalar_upper": 181098496 + }, + "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": "174299999253/175000000000", + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "296613239576267/98000000000000000", + "fused_gaussian": "296613238728801/98000000000000000", + "global_coordinate_router": "1059333/350000000", + "group_bit_router": "741533446822001/245000000000000000", + "group_scans": "349999999/350000000", + "main_transform": "296613099576267/98000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "40109113239576267/98000000000000000" + }, + "parameters": { + "a": "1059333/350000000", + "b": "2118667/700000000", + "beta": "699999997/700000000", + "bit_saving": "17/5000", + "cap_xi": "89109113099576267/98000000000000000", + "complex_uniform_saving": "529667/175000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "151333/50000000", + "lambda_": "199394667/200000000", + "lambda_prime": "139576267/140000000", + "layout": "1/700000000", + "q": "423733/140000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "302667/100000000" + }, + "strict_checks": { + "actual_bit_above_effective": "130667/350000000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "8890887110423733/49000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "559576267/98000000000000000", + "cap_above_band": "40109113099576267/98000000000000000", + "cap_below_cell": "8890886760423733/98000000000000000", + "cap_below_phase_cell_power": "106890886900423733/98000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19756333/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "558728801/98000000000000000", + "gaussian_above_main": "69576267/49000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "1746822001/245000000000000000", + "group_gauge_power_slack": "8890887103423733/49000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "87235167/87500000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "647844790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1397881333/490000000000000000", + "leaf_saving_above_effective": "697881333/490000000000000000", + "main_transform_above_kappa": "419576267/98000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "26948940671/350000000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "697881337/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1397881333/490000000000000000", + "q_positive": "423733/140000000", + "short_record_fallback": "697881333/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "39812500559576267/98000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 41170, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 16 + }, + "paid_calls": 64148, + "productive_fields": 10800, + "query_shears": 15, + "rank_mass_surplus": 752, + "raw_headroom": [ + "1476807/100000000000000", + "184601/12500000000000" + ], + "raw_root_interval": [ + "302667476807/100000000000000", + "37833434601/12500000000000" + ], + "strictification": { + "alpha": { + "lower": "0.999999995016963387587258118166", + "upper": "0.999999995016963387587258118167" + }, + "cutoff": 20, + "delta": { + "lower": "0.951652473261883819699264316643", + "upper": "0.951652473261883819699264316644" + }, + "floor": 21, + "gamma": { + "lower": "0.956968564096059991841792406781", + "upper": "0.956968564096059991841792406782" + }, + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "reserve": "1/1000000000", + "tail_offset": "1/5", + "tested": "302667/100000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5740 + } + }, + "candidate_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 318 + }, + "independent_owned_entry_columns": 17, + "independent_persistent_columns": 624, + "max_denominator": 64, + "max_formal_prefix_l1": "163", + "owned_outputs_zero": true, + "paid": { + "1": 2193, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "real_scalar_allowance": 158744, + "zero_identities": 8 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "independent_source_identities": { + "checked": [ + [ + "center", + 11332 + ], + [ + "center", + 11358 + ], + [ + "center", + 11384 + ], + [ + "center", + 11410 + ], + [ + "center", + 11436 + ], + [ + "center", + 11462 + ], + [ + "center", + 11488 + ], + [ + "center", + 11514 + ], + [ + "zero", + 15584 + ], + [ + "zero", + 15870 + ], + [ + "zero", + 15876 + ], + [ + "zero", + 17245 + ], + [ + "zero", + 17256 + ], + [ + "zero", + 17264 + ], + [ + "zero", + 17580 + ], + [ + "zero", + 17722 + ] + ], + "owned_pivots": [ + 225, + 227, + 229, + 230, + 241, + 245, + 257, + 288 + ], + "reduced_basis": { + "225": { + "225": "1", + "384": "-1", + "388": "-1", + "390": "1", + "391": "1", + "392": "1", + "397": "-1" + }, + "227": { + "227": "1", + "231": "1", + "232": "-1", + "234": "1", + "235": "1", + "237": "1", + "238": "-1", + "239": "-1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + }, + "229": { + "229": "1", + "231": "-1", + "236": "-1", + "238": "1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + }, + "230": { + "230": "1", + "324": "-1", + "326": "1", + "328": "1", + "333": "-1" + }, + "241": { + "241": "1", + "243": "-1", + "253": "-1", + "255": "1", + "324": "1/2", + "326": "-1/2", + "328": "-1/2", + "333": "1/2" + }, + "245": { + "245": "1", + "247": "-1", + "252": "-1", + "254": "1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + }, + "257": { + "257": "1", + "259": "-1", + "261": "1", + "263": "-1", + "268": "-1", + "269": "-1", + "270": "1", + "271": "1" + }, + "288": { + "288": "1", + "294": "-1", + "296": "-1", + "297": "-1", + "300": "1", + "303": "1" + } + }, + "relation_rank": 8, + "snapshot_terms_before_substitution": { + "11205": 61, + "11218": 63, + "11231": 73, + "11244": 68, + "11257": 64, + "11270": 75, + "11283": 64, + "11306": 62 + }, + "source_event_indices_are_zero_based": true, + "witnesses": [ + { + "cached_event": 11205, + "cached_role": 92, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11332, + "frame": 254, + "relation": [ + [ + 230, + "1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ] + ], + "zero_event": 15584, + "zero_factor": "-1/4", + "zero_role": 92 + }, + { + "cached_event": 11218, + "cached_role": 57, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11358, + "frame": 274, + "relation": [ + [ + 225, + "1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zero_event": 17264, + "zero_factor": "-1/4", + "zero_role": 57 + }, + { + "cached_event": 11231, + "cached_role": 81, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11384, + "frame": 619, + "relation": [ + [ + 225, + "1" + ], + [ + 227, + "-1" + ], + [ + 229, + "1" + ], + [ + 231, + "-2" + ], + [ + 232, + "1" + ], + [ + 234, + "-1" + ], + [ + 235, + "-1" + ], + [ + 236, + "-1" + ], + [ + 237, + "-1" + ], + [ + 238, + "2" + ], + [ + 239, + "1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zero_event": 17256, + "zero_factor": "-1/4", + "zero_role": 81 + }, + { + "cached_event": 11244, + "cached_role": 224, + "copy_factor": "1", + "difference_factor": "-1/4", + "event": 11410, + "frame": 279, + "relation": [ + [ + 227, + "1" + ], + [ + 229, + "1" + ], + [ + 232, + "-1" + ], + [ + 234, + "1" + ], + [ + 235, + "1" + ], + [ + 236, + "-1" + ], + [ + 237, + "1" + ], + [ + 239, + "-1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ] + ], + "zero_event": 17722, + "zero_factor": "1/4", + "zero_role": 224 + }, + { + "cached_event": 11257, + "cached_role": 11, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11436, + "frame": 621, + "relation": [ + [ + 241, + "1" + ], + [ + 243, + "-1" + ], + [ + 245, + "1" + ], + [ + 247, + "-1" + ], + [ + 252, + "-1" + ], + [ + 253, + "-1" + ], + [ + 254, + "1" + ], + [ + 255, + "1" + ] + ], + "zero_event": 15876, + "zero_factor": "-1/4", + "zero_role": 11 + }, + { + "cached_event": 11270, + "cached_role": 240, + "copy_factor": "1", + "difference_factor": "-1/4", + "event": 11462, + "frame": 280, + "relation": [ + [ + 225, + "1" + ], + [ + 241, + "-1" + ], + [ + 243, + "1" + ], + [ + 245, + "1" + ], + [ + 247, + "-1" + ], + [ + 252, + "-1" + ], + [ + 253, + "1" + ], + [ + 254, + "1" + ], + [ + 255, + "-1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zero_event": 17245, + "zero_factor": "1/4", + "zero_role": 240 + }, + { + "cached_event": 11283, + "cached_role": 9, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11488, + "frame": 624, + "relation": [ + [ + 257, + "1" + ], + [ + 259, + "-1" + ], + [ + 261, + "1" + ], + [ + 263, + "-1" + ], + [ + 268, + "-1" + ], + [ + 269, + "-1" + ], + [ + 270, + "1" + ], + [ + 271, + "1" + ] + ], + "zero_event": 15870, + "zero_factor": "-1/4", + "zero_role": 9 + }, + { + "cached_event": 11306, + "cached_role": 288, + "copy_factor": "1", + "difference_factor": "1/4", + "event": 11514, + "frame": 281, + "relation": [ + [ + 288, + "1" + ], + [ + 294, + "-1" + ], + [ + 296, + "-1" + ], + [ + 297, + "-1" + ], + [ + 300, + "1" + ], + [ + 303, + "1" + ] + ], + "zero_event": 17580, + "zero_factor": "-1/4", + "zero_role": 288 + } + ] + }, + "native_negative_controls": { + "missing_owned_input_clear": "Every independent main/helper endpoint: 0", + "uncleared_owned_output": "Every owned entry column is erased at return", + "under_or_overstated_paid_rank": "Exact paid rank and frame", + "wrong_copy_gauge": "Exact scalar destination frame", + "wrong_relation_sign": "Every independent main/helper endpoint: 0", + "wrong_snapshot_source": "Zero identity requires an identically zero full row", + "wrong_zero_input_frame": "Declared zero identity" + }, + "phase_inheritance": { + "absolute_phase_receipt_reused": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "all_retained_paid_events_and_warps_from_source": true, + "new_gaussian_operators": 0, + "new_native_maps": 0, + "new_operations": "Same-frame COPY, owned CLEAR/ADD, and physical identity on a proved zero row.", + "source_amplitudes_and_phase_lowering_freshly_replayed": false + }, + "scope": "Exact finite word, full all-column endpoints, ownership, p16 bill and compiler arithmetic. Retains source native phase, allowed owned erasure, mixed-target all-size, analytic, precision, tape, prime and exact-recovery contracts. No selected-frontier update.", + "source_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158168, + "zero_identities": 0 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_CONDITIONAL_KAPPA_00302666_EIGHT_JOINT_RELATIONS", + "word_payload_sha256": "2aee5e997df99726fc763e510d9cb69fbe4f86114dc8d2cd33ad26c6c462a21d" +} diff --git a/research/geometric-tail-compiler/vendor/RELATIONS.json b/research/geometric-tail-compiler/vendor/RELATIONS.json new file mode 100644 index 0000000000..f558b9ddd9 --- /dev/null +++ b/research/geometric-tail-compiler/vendor/RELATIONS.json @@ -0,0 +1,652 @@ +{ + "pivots": [ + 225, + 227, + 229, + 230, + 241, + 245, + 257, + 261 + ], + "rows": [ + { + "225": "1", + "384": "-1", + "388": "-1", + "390": "1", + "391": "1", + "392": "1", + "397": "-1" + }, + { + "227": "1", + "231": "1", + "232": "-1", + "234": "1", + "235": "1", + "237": "1", + "238": "-1", + "239": "-1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + }, + { + "229": "1", + "236": "-1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2", + "231": "-1", + "238": "1" + }, + { + "230": "1", + "324": "-1", + "326": "1", + "328": "1", + "333": "-1" + }, + { + "241": "1", + "243": "-1", + "253": "-1", + "255": "1", + "324": "1/2", + "326": "-1/2", + "328": "-1/2", + "333": "1/2" + }, + { + "245": "1", + "247": "-1", + "252": "-1", + "254": "1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + }, + { + "257": "1", + "259": "-1", + "269": "-1", + "271": "1", + "324": "1/2", + "326": "-1/2", + "328": "-1/2", + "333": "1/2" + }, + { + "261": "1", + "263": "-1", + "268": "-1", + "270": "1", + "324": "-1/2", + "326": "1/2", + "328": "1/2", + "333": "-1/2" + } + ], + "sites": [ + { + "score": 0.009448442829157244, + "center": 11332, + "snapshot": 11205, + "role": [ + "L", + 92 + ], + "frame": 254, + "relation": [ + [ + 230, + "1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ] + ], + "zeros": [ + [ + 15584, + 1, + [ + "L", + 92 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11358, + "snapshot": 11218, + "role": [ + "L", + 57 + ], + "frame": 274, + "relation": [ + [ + 225, + "1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zeros": [ + [ + 17264, + 1, + [ + "L", + 57 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11384, + "snapshot": 11231, + "role": [ + "L", + 81 + ], + "frame": 619, + "relation": [ + [ + 225, + "1" + ], + [ + 227, + "-1" + ], + [ + 229, + "1" + ], + [ + 231, + "-2" + ], + [ + 232, + "1" + ], + [ + 234, + "-1" + ], + [ + 235, + "-1" + ], + [ + 236, + "-1" + ], + [ + 237, + "-1" + ], + [ + 238, + "2" + ], + [ + 239, + "1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zeros": [ + [ + 17256, + 1, + [ + "L", + 81 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11410, + "snapshot": 11244, + "role": [ + "L", + 224 + ], + "frame": 279, + "relation": [ + [ + 227, + "1" + ], + [ + 229, + "1" + ], + [ + 232, + "-1" + ], + [ + 234, + "1" + ], + [ + 235, + "1" + ], + [ + 236, + "-1" + ], + [ + 237, + "1" + ], + [ + 239, + "-1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ] + ], + "zeros": [ + [ + 17722, + 1, + [ + "L", + 224 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11436, + "snapshot": 11257, + "role": [ + "L", + 11 + ], + "frame": 621, + "relation": [ + [ + 241, + "1" + ], + [ + 243, + "-1" + ], + [ + 245, + "1" + ], + [ + 247, + "-1" + ], + [ + 252, + "-1" + ], + [ + 253, + "-1" + ], + [ + 254, + "1" + ], + [ + 255, + "1" + ] + ], + "zeros": [ + [ + 15876, + 1, + [ + "L", + 11 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11462, + "snapshot": 11270, + "role": [ + "L", + 240 + ], + "frame": 280, + "relation": [ + [ + 225, + "1" + ], + [ + 241, + "-1" + ], + [ + 243, + "1" + ], + [ + 245, + "1" + ], + [ + 247, + "-1" + ], + [ + 252, + "-1" + ], + [ + 253, + "1" + ], + [ + 254, + "1" + ], + [ + 255, + "-1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zeros": [ + [ + 17245, + 1, + [ + "L", + 240 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11488, + "snapshot": 11283, + "role": [ + "L", + 9 + ], + "frame": 624, + "relation": [ + [ + 257, + "1" + ], + [ + 259, + "-1" + ], + [ + 261, + "1" + ], + [ + 263, + "-1" + ], + [ + 268, + "-1" + ], + [ + 269, + "-1" + ], + [ + 270, + "1" + ], + [ + 271, + "1" + ] + ], + "zeros": [ + [ + 15870, + 1, + [ + "L", + 9 + ] + ] + ] + }, + { + "score": 0.009448442829157244, + "center": 11514, + "snapshot": 11296, + "role": [ + "L", + 256 + ], + "frame": 281, + "relation": [ + [ + 225, + "1" + ], + [ + 257, + "-1" + ], + [ + 259, + "1" + ], + [ + 261, + "1" + ], + [ + 263, + "-1" + ], + [ + 268, + "-1" + ], + [ + 269, + "1" + ], + [ + 270, + "1" + ], + [ + 271, + "-1" + ], + [ + 324, + "-1" + ], + [ + 326, + "1" + ], + [ + 328, + "1" + ], + [ + 333, + "-1" + ], + [ + 384, + "-1" + ], + [ + 388, + "-1" + ], + [ + 390, + "1" + ], + [ + 391, + "1" + ], + [ + 392, + "1" + ], + [ + 397, + "-1" + ] + ], + "zeros": [ + [ + 17233, + 1, + [ + "L", + 256 + ] + ] + ] + } + ] +} diff --git a/research/geometric-tail-compiler/vendor/RESULT.json b/research/geometric-tail-compiler/vendor/RESULT.json new file mode 100644 index 0000000000..2e13818df0 --- /dev/null +++ b/research/geometric-tail-compiler/vendor/RESULT.json @@ -0,0 +1,429 @@ +{ + "arithmetic": { + "compiler": { + "H": 409549000000000000, + "N": "2^409549000000000000", + "eta": { + "lower": "0.000000199491021599850733809086", + "upper": "0.000000199491021599850733809087" + }, + "gap": "1/7000000000000", + "integer_test_exponent": 58507, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "21186723361/7000000000000", + "word_materialized": false + }, + "completion_reserve": "1/1000000000000", + "fixed_profile_ceiling": { + "decreasing_through": "1/20", + "derivative_upper": { + "lower": "-195473.450610684184815935477074865515", + "upper": "-195473.450610684184815935477074865514" + }, + "remaining_interval_moment_upper": { + "lower": "-6820.155255095433991980526890420873", + "upper": "-6820.155255095433991980526890420872" + } + }, + "full_backward": 16, + "full_forward": 2, + "gain_over_PR4610": "979793/200000000000", + "gain_over_PR5383": "2953/200000000000", + "kappa": "605334953/200000000000", + "kappa_decimal": ".003026674765", + "margin_at_previous_kappa": { + "lower": "1.209169472215494738857340795394", + "upper": "1.209169472215494738857340795395" + }, + "margin_at_previous_root_upper": { + "lower": "1.209152002019805295008574084544", + "upper": "1.209152002019805295008574084545" + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unearned_helper_credit": "Rejected by the independent complete census", + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "additional_private_slots": 8, + "local_routes": 4834000, + "local_scalar": 158776, + "owned_slots_backward": 17, + "raw_budget": 1000000000, + "raw_scalar_upper": 181098496 + }, + "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": "1742999999999253/1750000000000000", + "fixed_halo_explicit_metadata_branch": "134750000000001/1750000000000", + "new_BIT_row_stock_sublinear_in_active_group": "6978999999997009/7000000000000000", + "new_semantic_group_guard": "3/7000000000000" + }, + "margins": { + "boundary_algebraic_matrix": "74153531756489406638321/24500000000000000000000000", + "fused_gaussian": "74153531756468219914963/24500000000000000000000000", + "global_coordinate_router": "21186723359/7000000000000", + "group_bit_router": "148307063519936439829923/49000000000000000000000000", + "group_scans": "3499999999999/3500000000000", + "main_transform": "74153531752989406638321/24500000000000000000000000", + "microbox_face_corrections": "134750000000001/1750000000000", + "polynomial_products": "6999999999999/7000000000000", + "sparse_union_movement": "10027278531756489406638321/24500000000000000000000000" + }, + "parameters": { + "a": "21186723359/7000000000000", + "b": "132417021/43750000000", + "beta": "6999999999997/7000000000000", + "bit_saving": "17/5000", + "cap_xi": "22277278531752989406638321/24500000000000000000000000", + "complex_uniform_saving": "21186723361/7000000000000", + "d": "1/7000000000000", + "epsilon": "6999999999999/7000000000000", + "kappa": "605334953/200000000000", + "lambda_": "1993946650469/2000000000000", + "lambda_prime": "3489406638321/3500000000000", + "layout": "1/7000000000000", + "q": "10593361679/3500000000000", + "r0": "1/70000000000000", + "stop": "1/7000000000000", + "tested_saving": "1513337383/500000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "2613276641/7000000000000", + "actual_logarithmic_gamma_guard": "1/7000000000000", + "actual_logarithmic_group_guard": "2222721468252260593361679/12250000000000000000000000", + "alpha_logarithm_absorption": "1/70000000000000", + "boundary_algebraic_matrix_above_kappa": "13989406638321/24500000000000000000000000", + "cap_above_band": "10027278531752989406638321/24500000000000000000000000", + "cap_below_cell": "2222721468243510593361679/24500000000000000000000000", + "cap_below_phase_cell_power": "26722721468247010593361679/24500000000000000000000000", + "complex_above_effective": "1/7000000000000", + "complex_below_one_over_32": "1234770479/43750000000", + "complex_endpoint": "1/3500000000000", + "epsilon_below_one": "1/7000000000000", + "epsilon_positive": "6999999999999/7000000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "13968219914963/24500000000000000000000000", + "gaussian_above_main": "1739406638321/12250000000000000000000000", + "global_coordinate_router_above_kappa": "1/1750000000000", + "global_gamma_power_slack": "9/70000000000000", + "group_below_dimension": "1/3500000000000", + "group_bit_router_above_kappa": "34936439829923/49000000000000000000000000", + "group_gauge_power_slack": "2222721468252085593361679/12250000000000000000000000", + "group_key_fits_record": "1/3500000000000", + "group_positive": "6999999999997/7000000000000", + "group_scans_above_kappa": "6978813276643/7000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "647852172900418148631/500000000000000000000000", + "lambda_above_internal": "1/14000000000000", + "lambda_above_sigma": "3/14000000000000", + "lambda_above_tau": "1/14000000000000", + "lambda_prime_above_lambda": "1/14000000000000", + "lambda_prime_above_leaf": "87367582979/306250000000000000000000", + "leaf_saving_above_effective": "43617582979/306250000000000000000000", + "main_transform_above_kappa": "10489406638321/24500000000000000000000000", + "membership_arithmetic_fits_record": "1/7000000000000", + "microbox_face_corrections_above_kappa": "538978813276649/7000000000000", + "microbox_halo_volume": "553000000000003/7000000000000", + "new_complex_uniform_saving_above_b": "1/7000000000000", + "new_semantic_guard_with_C1_one": "1/7000000000000", + "polynomial_products_above_kappa": "1744703319161/1750000000000", + "positive_layout_slack": "1/7000000000000", + "q_below_effective": "1/7000000000000", + "q_below_internal": "1/7000000000000", + "q_below_leaf": "87367582979/306250000000000000000000", + "q_positive": "10593361679/3500000000000", + "short_record_fallback": "43617582979/43750000000", + "source_axis_superpolynomial": "1/7000000000000", + "sparse_union_movement_above_kappa": "9953125000013989406638321/24500000000000000000000000", + "stop_below_one": "6999999999999/7000000000000", + "stop_positive": "1/7000000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/7000000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/7000000000000", + "union_tag_work_per_visit_fits_record": "3/7000000000000" + } + }, + "paid": { + "1": 41170, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 16 + }, + "paid_calls": 64148, + "productive_fields": 10800, + "query_shears": 15, + "rank_mass_surplus": 752, + "raw_headroom": [ + "307/100000000000000", + "77/25000000000000" + ], + "raw_root_interval": [ + "302667476807/100000000000000", + "37833434601/12500000000000" + ], + "strictification": { + "alpha": { + "lower": "0.999999999997831927004289535030", + "upper": "0.999999999997831927004289535031" + }, + "cutoff": 20, + "delta": { + "lower": "0.951652475842024105512105409944", + "upper": "0.951652475842024105512105409945" + }, + "floor": 21, + "gamma": { + "lower": "0.956968566609975897371044048406", + "upper": "0.956968566609975897371044048407" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_offset": "1/5", + "tested": "1513337383/500000000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5740 + } + }, + "candidate_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 318 + }, + "independent_owned_entry_columns": 17, + "independent_persistent_columns": 624, + "max_denominator": 64, + "max_formal_prefix_l1": "163", + "owned_outputs_zero": true, + "paid": { + "1": 2193, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "real_scalar_allowance": 158776, + "zero_identities": 8 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "independent_source_identities": [ + { + "center": 11332, + "center_factor": "1/4", + "site": 0, + "zero_factor": "-1/4" + }, + { + "center": 11358, + "center_factor": "1/4", + "site": 1, + "zero_factor": "-1/4" + }, + { + "center": 11384, + "center_factor": "1/4", + "site": 2, + "zero_factor": "-1/4" + }, + { + "center": 11410, + "center_factor": "-1/4", + "site": 3, + "zero_factor": "1/4" + }, + { + "center": 11436, + "center_factor": "1/4", + "site": 4, + "zero_factor": "-1/4" + }, + { + "center": 11462, + "center_factor": "-1/4", + "site": 5, + "zero_factor": "1/4" + }, + { + "center": 11488, + "center_factor": "1/4", + "site": 6, + "zero_factor": "-1/4" + }, + { + "center": 11514, + "center_factor": "-1/4", + "site": 7, + "zero_factor": "1/4" + } + ], + "native_negative_controls": { + "missing_owned_input_clear": "Every independent main/helper endpoint: 0", + "uncleared_owned_output": "Every owned entry column is erased at return", + "under_or_overstated_paid_rank": "Exact paid rank and frame", + "wrong_copy_gauge": "Exact scalar destination frame", + "wrong_prepared_pivot_225": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_227": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_229": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_230": "Every independent main/helper endpoint: 0", + "wrong_prepared_pivot_241": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_245": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_257": "Every independent main/helper endpoint: 1", + "wrong_prepared_pivot_261": "Every independent main/helper endpoint: 1", + "wrong_relation_sign": "Every independent main/helper endpoint: 0", + "wrong_snapshot_source": "Zero identity requires an identically zero full row", + "wrong_zero_input_frame": "Zero identity requires an identically zero full row" + }, + "phase_inheritance": { + "absolute_phase_receipt_reused": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "all_retained_paid_events_and_warps_from_source": true, + "new_gaussian_operators": 0, + "new_native_maps": 0, + "new_operations": "Same-frame COPY, owned CLEAR/ADD, and physical identity on a proved zero row.", + "source_amplitudes_and_phase_lowering_freshly_replayed": false + }, + "relation_basis": { + "dyadic": true, + "pivots": [ + 225, + 227, + 229, + 230, + 241, + 245, + 257, + 261 + ], + "rank": 8 + }, + "scope": "Exact finite word, full all-column endpoints, ownership, p16 bill and compiler arithmetic. Retains source native phase, allowed owned erasure, mixed-target all-size, analytic, precision, tape, prime and exact-recovery contracts. No selected-frontier update.", + "source_native": { + "backward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 64, + "max_formal_prefix_l1": "169", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158168, + "zero_identities": 0 + }, + "forward": { + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "independent_owned_entry_columns": 1, + "independent_persistent_columns": 632, + "max_denominator": 32, + "max_formal_prefix_l1": "457", + "owned_outputs_zero": true, + "paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "real_scalar_allowance": 158120, + "zero_identities": 0 + } + }, + "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd", + "status": "PASS_CONDITIONAL_KAPPA_003026674765_COMPILER_MARGIN", + "word_payload_sha256": "9aa0d7112b4e13f1aa13a93dab0af6f4435ffe99b842aad841685becdafee492" +} diff --git a/research/geometric-tail-compiler/vendor/SOURCES.json b/research/geometric-tail-compiler/vendor/SOURCES.json new file mode 100644 index 0000000000..71c57c8a90 --- /dev/null +++ b/research/geometric-tail-compiler/vendor/SOURCES.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/free-word-tensor-lift-audit/PROOF.md", + "usage": "provenance", + "git_blob": "69c337a7704ce589798269ab4b8606189c070c4e", + "sha256": "cc8ad3698a673fb225419a3636a39aa99a66c7a0676f12e329b1e76564fa1459" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/joint-helper-lattice/CONTROLLER.json", + "usage": "input", + "git_blob": "49a2f0675819f9deeea27ed77be2c2b6ff2e87e5", + "sha256": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f" + }, + { + "path": "research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py", + "usage": "input", + "git_blob": "5a55034ec9e6185d981e16c28e1e2e455069e2cb", + "sha256": "106b4d5e052427230df452f0c901d5390a0583782960b80a8af94d9a984022c7" + }, + { + "path": "research/kappa-interface-round2-20261022/price_profile.py", + "usage": "provenance", + "git_blob": "1d93e43d1cb888d128c2faa2be83a96d85b84295", + "sha256": "adde619968d3ac37147d239e25145b28150650e9ce0f76035f680f22589adcbb" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/kappa-rebuild/complex/native_extensions.py", + "usage": "provenance", + "git_blob": "7f84894efc309546a903d314c7ac1473e7f594a8", + "sha256": "50ad007d9c386393657e86c99a96ae0a63a8fbc52872579b185002cc626e88e3" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz", + "usage": "input", + "git_blob": "ac77b78547d6dbf2e6bd102e1047c5b16c1bca88", + "sha256": "6eae66ed3cfa8a1533e89b9660a57276908e6646640a12f8b1e3489f4ea1354b" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "usage": "input", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/query-thinned-controllers/RESULT.json", + "usage": "input", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f" + } + ] +} diff --git a/research/geometric-tail-compiler/vendor/WORD.json.gz b/research/geometric-tail-compiler/vendor/WORD.json.gz new file mode 100644 index 0000000000..c62fcb5964 Binary files /dev/null and b/research/geometric-tail-compiler/vendor/WORD.json.gz differ diff --git a/research/geometric-tail-compiler/vendor/native.py b/research/geometric-tail-compiler/vendor/native.py new file mode 100644 index 0000000000..86c10d2e1e --- /dev/null +++ b/research/geometric-tail-compiler/vendor/native.py @@ -0,0 +1,329 @@ +"""Eight jointly prepared helpers remove sixteen paid jobs in the PR4610 backward word. + +Derived from Ali Romman PR5377; joint construction by Dugongue. +Both with substantial OpenAI Codex assistance. Apache-2.0. +The source word is by Cao Yifan. The row convention and scalar allowance +follow the credited native work of Cinna Davis and zxv. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = 'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz' +PHASE = 'research/kappa-round3-warp-20261022/PHASE-VALIDATION.json.gz' +PAYLOAD = 'cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd' +OLD_PAID = {1: 2201, 2: 412, 3: 510, 4: 127, 5: 40, 8: 8} +NEW_PAID = dict(OLD_PAID) +NEW_PAID[1] -= 8 +NEW_PAID.pop(8) +OLD_HELPERS = {4: 28, 7: 7, 8: 47, 9: 326} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +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 load(relative, name): + spec = importlib.util.spec_from_file_location(name, ROOT / relative) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def authenticate(): + pins = read(HERE / 'SOURCES.json') + for row in pins['files']: + if row['usage'] != 'input': + continue + p = ROOT + for part in Path(row['path']).parts: + p /= part + need(not p.is_symlink(), 'No source aliases') + raw = p.read_bytes() + need(sha256(raw).hexdigest() == row['sha256'], 'Changed source: ' + row['path']) + need(sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() == row['git_blob'], 'Source Git blob') + need(sha256(gzip.decompress((ROOT / SOURCE).read_bytes())).hexdigest() == PAYLOAD, 'Exact source payload') + return pins + + +def span(basis): + out = {0} + for vector in basis: + need(isinstance(vector, int) and 0 <= vector < 512, 'Binary frame coordinate') + out |= {v ^ vector for v in tuple(out)} + need(len(out) == 2 ** len(basis), 'Independent frame basis') + return out + + +def add(dst, src, q): + for k, v in tuple(src.items()): + value = dst.get(k, Q(0)) + q * v + if value: + dst[k] = value + else: + dst.pop(k, None) + + +def allowance(g): + if g[0] in ('clear', 'copy'): + return 2 + q = Q(*g[3:]) if g[0] == 'add' else Q(*g[2:]) + n, d = abs(q.numerator), q.denominator + need(n > 0 and d & (d - 1) == 0, 'Nonzero dyadic scalar') + if g[0] == 'scale': + need(n & (n - 1) == 0, 'Dyadic unit SCALE') + return 2 * (abs(n.bit_length() - d.bit_length()) + int(q < 0)) + need(g[0] == 'add', 'Known scalar operation') + return 2 * (3 + n.bit_length() - 1 + n.bit_count() + d.bit_length() - 1) + + +RELATIONS = json.loads((HERE / 'RELATIONS.json').read_text()) +PIVOTS = set(RELATIONS['pivots']) +SITES = RELATIONS['sites'] + + +def check_relation_basis(): + rows=[{int(h):Q(q)for h,q in x['relation']}for x in SITES] + pivots=[] + for i in range(8): + need(any(rows[j]for j in range(i,8)), 'Eight independent relations') + h=min(k for j in range(i,8)for k in rows[j]) + j=next(j for j in range(i,8)if rows[j].get(h)) + rows[i],rows[j]=rows[j],rows[i];q=rows[i][h] + rows[i]={k:v/q for k,v in rows[i].items()} + for j in range(8): + if j!=i:add(rows[j],rows[i],-rows[j].get(h,Q(0))) + pivots.append(h) + need(pivots==RELATIONS['pivots'], 'Exact eight-pivot row reduction') + need(rows==[{int(h):Q(q)for h,q in r.items()}for r in RELATIONS['rows']], 'Exact reduced preparation matrix') + need(all(q.denominator & (q.denominator-1)==0 for r in rows for q in r.values()),'Dyadic joint preparation') + return {'rank':8,'pivots':pivots,'dyadic':True} + +def construct(source): + c = source['canonical']; old = source['programs']['backward'] + need(len(PIVOTS) == 8 and len(SITES) == 8, 'Eight pivots and sites') + word = [] + for pivot, rr in zip(RELATIONS['pivots'], RELATIONS['rows']): + row = {int(h): Q(q) for h,q in rr.items()} + need(row[pivot] == 1 and all(row.get(h,0)==0 for h in PIVOTS-{pivot}), 'Reduced independent preparation') + need(all(c['start'][h]==0 and c['final'][h]==1 for h in row), 'Cold full-ended helper relation') + word.append(['scalar',['clear',['L',pivot]],0]) + for h,q in sorted(row.items()): + if h != pivot:word.append(['scalar',['add',['L',pivot],['L',h],(-q).numerator,q.denominator],0]) + centers={x['center']:(j+1,x) for j,x in enumerate(SITES)} + snapshots={x['snapshot']:(j+1,x) for j,x in enumerate(SITES)} + zeros={x['zeros'][0][0]:x for x in SITES} + need(len(centers)==len(snapshots)==len(zeros)==8,'Distinct rewrite events') + for i,event in enumerate(old): + if i in centers: + j,x=centers[i];f=x['frame'] + need(event==['center',0,0,f,8],'Source center') + word += [['scalar',['clear',['C',0]],f],['scalar',['copy',['C',0],['C',j]],f],['scalar',['clear',['C',j]],f]] + elif i in zeros: + x=zeros[i];need(event[0]=='climb' and event[-1]==1,'Source zero job') + word.append(['zero_retag',['L',event[2]],event[3],event[4]]) + else:word.append(deepcopy(event)) + if i in snapshots: + j,x=snapshots[i];f=x['frame'] + word += [['scalar',['clear',['C',j]],f],['scalar',['copy',['C',j],x['role']],f]] + for h in sorted(PIVOTS):word.append(['scalar',['clear',['L',h]],1]) + physical=deepcopy(c);physical.pop('local_profile') + return {'schema':'eight-owned-helper-relations/1','canonical':physical,'paid_profiles':{'forward':OLD_PAID,'backward':NEW_PAID}, + 'owned':{'forward':[['C',0]],'backward':[['C',i] for i in range(9)]+[['L',h]for h in sorted(PIVOTS)]}, + 'programs':{'forward':deepcopy(source['programs']['forward']),'backward':word}} + + +def replay(c, program, backward, specialized): + """Run every event on all independent entry columns and exact frames.""" + owned = {('C', 0)} | ({('C', j) for j in range(1,9)} | {('L',h) for h in PIVOTS} if specialized else set()) + roles = {('L', i) for i in range(632)} | owned + rows = {r: {(r, ()): Q(1)} for r in roles} + frames = {('L', i): f for i, f in enumerate(c['start'])} + frames.update({r: None for r in owned if r[0] == 'C'}) + spaces = [span(b) for b in c['frames']] + paid = Counter() + cost, max_l1, denominator, zero_count = 0, Q(1), 1, 0 + for e in program: + kind, touched = e[0], None + if kind == 'scalar': + g, frame = e[1:] + dst = tuple(g[1]); touched = dst + need(dst in rows and 0 <= frame < len(spaces), 'Declared scalar destination and frame') + cost += allowance(g) + if g[0] == 'clear': + need(dst in owned, 'Only owned fields can be erased') + rows[dst] = {}; frames[dst] = frame + else: + need(frames[dst] == frame, 'Exact scalar destination frame') + if g[0] in ('add', 'copy'): + src = tuple(g[2]) + need(src in rows and frames[src] == frame and dst != src, 'Exact scalar source frame') + if g[0] == 'copy': + need(dst in owned and not rows[dst], 'COPY into cleared owned storage') + rows[dst] = dict(rows[src]) + else: + add(rows[dst], rows[src], Q(g[3], g[4])) + else: + need(g[0] == 'scale', 'Known scalar operation') + rows[dst] = {k: Q(g[2], g[3]) * v for k, v in rows[dst].items()} + elif kind == 'warp': + _, role, op, old, new = e + dst = tuple(role); touched = dst + need(frames[dst] == old and 1 <= abs(op) <= len(c['warps']), 'Exact warp input') + symbol = (1 if op > 0 else -1) * (abs(op) + (10**6 if backward else 0)) + rows[dst] = {(r, w[1:] if w and w[0] == -symbol else (symbol,) + w): q + for (r, w), q in rows[dst].items()} + frames[dst] = new + elif kind in ('climb', 'center'): + if kind == 'climb': + _, _, i, old, new, rank = e + dst = ('L', i) + need(spaces[old] < spaces[new], 'Ascending paid climb') + else: + _, i, old, new, rank = e + dst = ('C', i) + need(spaces[old] < spaces[new] or spaces[new] < spaces[old], 'Nested paid center') + need(frames[dst] == old and rank == abs(len(c['frames'][new]) - len(c['frames'][old])), 'Exact paid rank and frame') + frames[dst] = new; paid[rank] += 1 + elif kind == 'zero_retag': + _, role, old, new = e + dst = tuple(role) + need(specialized and backward and dst in {tuple(x['zeros'][0][2]) for x in SITES}, 'Declared zero identity') + need(frames[dst] == old and not rows[dst], 'Zero identity requires an identically zero full row') + need(any(tuple(x['zeros'][0][2])==dst and x['frame']==old and new==1 for x in SITES), 'Declared zero frame change') + frames[dst] = new; zero_count += 1 + else: + need(kind in ('phase', 'adapter'), 'Known inert source marker') + if touched is not None: + max_l1 = max(max_l1, sum(map(abs, rows[touched].values()), Q(0))) + denominator = max(denominator, max((q.denominator for q in rows[touched].values()), default=1)) + need([frames['L', i] for i in range(632)] == c['final'], 'Every final native frame') + for i in range(632): + r = ('L', i) + if r in owned: + continue + expected = {(r, ()): Q(1)} + if i < 112 if backward else 112 <= i < 224: + expected[(('L', i + 112 if backward else i - 112), ())] = Q(-1 if backward else 1) + need(rows[r] == expected, 'Every independent main/helper endpoint: ' + str(i)) + need(all(not rows[r] for r in owned), 'Every owned entry column is erased at return') + need(zero_count == 8*int(specialized), 'Exactly eight checked zero identities') + helpers = Counter() + for i in range(224, 632): + if ('L', i) in owned: + continue + a, b = c['start'][i], c['final'][i] + need(spaces[a] < spaces[b], 'Strict independent productive helper') + helpers[len(c['frames'][b]) - len(c['frames'][a])] += 1 + need(max_l1 < 2**192 and denominator < 2**192, 'Retained formal prefix envelope') + return {'paid': dict(sorted(paid.items())), 'helpers': dict(sorted(helpers.items())), + 'independent_persistent_columns': 624 if specialized else 632, + 'independent_owned_entry_columns': len(owned), 'owned_outputs_zero': True, + 'real_scalar_allowance': cost, 'max_formal_prefix_l1': str(max_l1), + 'max_denominator': denominator, 'zero_identities': zero_count} + + +def independent_source_identities(source): + v=load('research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','eight_relation_source_rows') + rows={('L',i):v.identity(('L',i)) for i in range(632)};rows['C',0]=v.identity(('C',0)) + saved={};receipt=[] + for index,e in enumerate(source['programs']['backward']): + if e[0]=='scalar': + g=e[1];dst=tuple(g[1]) + if g[0]=='clear':rows[dst]={} + elif g[0]=='copy':rows[dst]=dict(rows[tuple(g[2])]) + elif g[0]=='scale':rows[dst]={k:Q(g[2],g[3])*a for k,a in rows[dst].items()} + else:v.add(rows[dst],rows[tuple(g[2])],Q(g[3],g[4])) + elif e[0]=='warp': + dst=tuple(e[1]);rows[dst]=v.warp(rows[dst],e[2],True) + for j,x in enumerate(SITES): + delta={(('L',h),()):Q(q)for h,q in x['relation']} + if index==x['snapshot']:saved[j]=dict(rows[tuple(x['role'])]) + if index==x['center']: + diff=dict(rows['C',0]);v.add(diff,saved[j],-1) + factor=diff.get(min(delta),Q(0))/delta[min(delta)] + need(factor and diff=={k:factor*q for k,q in delta.items()},'Exact unrestricted center identity') + receipt.append({'site':j,'center':index,'center_factor':str(factor)}) + if index==x['zeros'][0][0]: + row=rows[tuple(x['zeros'][0][2])];factor=row.get(min(delta),Q(0))/delta[min(delta)] + need(factor and row=={k:factor*q for k,q in delta.items()},'Exact unrestricted zero identity') + next(z for z in receipt if z['site']==j)['zero_factor']=str(factor) + need(len(receipt)==8 and all('zero_factor'in x for x in receipt),'All sixteen source identities') + return receipt + + +def phase_inheritance(source, candidate): + receipt = read(ROOT / PHASE) + need(receipt['status'] == 'PASS_JOINT_HELPER_MAPS_ALL_ACTUAL_ABSOLUTE_PHASES' and + receipt['actual_word_canonical_sha256'] == PAYLOAD, 'Authenticated source absolute-phase receipt') + physical = deepcopy(source['canonical']); physical.pop('local_profile') + need(candidate['canonical'] == physical, 'Every frame, native map and main adapter unchanged') + for direction, program in candidate['programs'].items(): + old = source['programs'][direction] + for kind in ('warp', 'adapter', 'phase'): + need([e for e in program if e[0] == kind] == [e for e in old if e[0] == kind], 'Exact inherited ' + kind + ' sequence') + old_paid = Counter(tuple(e) for e in old if e[0] in ('climb', 'center')) + new_paid = Counter(tuple(e) for e in program if e[0] in ('climb', 'center')) + expected = Counter() if direction == 'forward' else Counter(tuple(old[i]) for x in SITES for i in (x['center'], x['zeros'][0][0])) + need(old_paid - new_paid == expected and not new_paid - old_paid, 'Only the sixteen proved jobs are removed') + return {'new_gaussian_operators': 0, 'new_native_maps': 0, + 'all_retained_paid_events_and_warps_from_source': True, + 'absolute_phase_receipt_reused': PHASE, + 'source_amplitudes_and_phase_lowering_freshly_replayed': False, + 'new_operations': 'Same-frame COPY, owned CLEAR/ADD, and physical identity on a proved zero row.'} + + +def controls(c, candidate): + controls = {} + base = candidate['programs']['backward'] + variants = {} + bad = deepcopy(base); bad[1][1][3] *= -1; variants['wrong_relation_sign'] = bad + variants['missing_owned_input_clear'] = deepcopy(base[1:]) + bad = deepcopy(base) + next(e for e in bad if e[0] == 'scalar' and e[1][:2] == ['copy', ['C', 1]])[1][2] = ['L', 63] + variants['wrong_snapshot_source'] = bad + bad = deepcopy(base); next(e for e in bad if e[0] == 'zero_retag')[2] = 0 + variants['wrong_zero_input_frame'] = bad + bad = deepcopy(base); next(e for e in bad if e[0] == 'climb')[5] += 1 + variants['under_or_overstated_paid_rank'] = bad + bad = deepcopy(base) + next(e for e in bad if e[0] == 'scalar' and e[1][:2] == ['copy', ['C', 0]])[2] = 0 + variants['wrong_copy_gauge'] = bad + for h in sorted(PIVOTS): + bad=deepcopy(base) + next(e for e in bad if e[0]=='scalar' and e[1][:2]==['add',['L',h]])[1][3]*=-1 + variants['wrong_prepared_pivot_'+str(h)]=bad + variants['uncleared_owned_output'] = deepcopy(base[:-1]) + for name, program in variants.items(): + try: + replay(c, program, True, True) + except ValueError as err: + controls[name] = str(err) + else: + raise ValueError('Control accepted: ' + name) + return controls diff --git a/research/geometric-tail-compiler/verify.py b/research/geometric-tail-compiler/verify.py new file mode 100644 index 0000000000..2d67657093 --- /dev/null +++ b/research/geometric-tail-compiler/verify.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python3 +"""Replay the eight-relation native word and its complete conditional kappa. + +Derived from Ali Romman PR5377; new construction by Dugongue, +with substantial OpenAI Codex assistance. Apache-2.0. +Read README.md for the source credit and inherited proof obligations. +""" +from hashlib import sha256 +import argparse +import gzip +import json +from pathlib import Path +import sys +sys.dont_write_bytecode = True +import importlib.util +HERE=Path(__file__).resolve().parent +vendor=HERE/'vendor' +manifest=json.loads((HERE/'VENDOR.json').read_text()) +for name,digest in manifest['files'].items(): + if sha256((vendor/name).read_bytes()).hexdigest()!=digest:raise ValueError('Frozen vendor drift: '+name) +spec=importlib.util.spec_from_file_location('native',vendor/'native.py') +N=importlib.util.module_from_spec(spec);sys.modules['native']=N;spec.loader.exec_module(N) +N.ROOT=HERE.parents[1] +import price + + + +def run(): + N.need(sha256((N.HERE/'PREDECESSOR-5383.json').read_bytes()).hexdigest() == 'd6a99bd75c6b7a2146b0fc4cfa038890aaf1d4adcdef42d767fdb40b687e61aa', 'Pinned PR5383 receipt') + N.authenticate() + from strictify import completed_upper, logarithm_power, finite_threshold + for args in [(1,0,price.Q(1,2),price.Q(1,2)),(1,price.Q(1,2),price.Q(1),price.Q(1,2)),(1,0.1,price.Q(1,2),price.Q(1,2))]: + try:completed_upper(*args) + except ValueError:pass + else:raise ValueError('Invalid or inexact completion input accepted') + for call in [lambda:logarithm_power(price.Q(1),price.Q(1,2),price.Q(2)),lambda:finite_threshold(price.Q(0),2)]: + try:call() + except ValueError:pass + else:raise ValueError('Invalid compiler input accepted') + relation_basis=N.check_relation_basis() + source = N.read(N.ROOT / N.SOURCE) + candidate = N.construct(source) + c = candidate['canonical'] + before, after = {}, {} + for direction in ('forward', 'backward'): + back = direction == 'backward' + before[direction] = N.replay(c, source['programs'][direction], back, False) + after[direction] = N.replay(c, candidate['programs'][direction], back, back) + N.need(before[direction]['paid'] == N.OLD_PAID and before[direction]['helpers'] == N.OLD_HELPERS, 'Pinned source census') + N.need(after[direction]['paid'] == candidate['paid_profiles'][direction], 'Emitted direction-specific paid profile') + helpers = dict(N.OLD_HELPERS) + if back: helpers[9] -= 8 + N.need(after[direction]['paid'] == (N.NEW_PAID if back else N.OLD_PAID) and after[direction]['helpers'] == helpers, 'Actual complete changed native census') + identities = N.independent_source_identities(source) + phase = N.phase_inheritance(source, candidate) + controls = N.controls(c, candidate) + arithmetic = price.run(after) + data = (json.dumps(candidate, sort_keys=True, separators=(',', ':')) + '\n').encode() + result = N.encode({'status': 'PASS_CONDITIONAL_KAPPA_0030266747680744_GEOMETRIC_TAILS', + 'relation_basis': relation_basis, 'source_payload_sha256': N.PAYLOAD, 'word_payload_sha256': sha256(data).hexdigest(), + 'source_native': before, 'candidate_native': after, 'independent_source_identities': identities, + 'phase_inheritance': phase, 'native_negative_controls': controls, 'arithmetic': arithmetic, + 'scope': 'Exact finite word, full all-column endpoints, ownership, p16 bill and compiler arithmetic. Retains source native phase, allowed owned erasure, mixed-target all-size, analytic, precision, tape, prime and exact-recovery contracts. No selected-frontier update.'}) + return data, result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true', help='Write only this package word and result after all checks pass.') + ap.add_argument('--out', type=Path, help='Write a replay result to a separate path.') + args = ap.parse_args() + data, result = run() + if args.write: + N.need(gzip.decompress((N.HERE/'WORD.json.gz').read_bytes())==data,'Frozen predecessor word unchanged') + (HERE / 'RESULT.json').write_text(json.dumps(result, indent=2, sort_keys=True) + '\n', encoding='utf-8') + else: + N.need(gzip.decompress((N.HERE / 'WORD.json.gz').read_bytes()) == data, 'Exact literal published word') + N.need(N.read(HERE / 'RESULT.json') == result, 'Exact published replay result') + if args.out: + args.out.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n', encoding='utf-8') + print(json.dumps({'status': result['status'], **{k: result['arithmetic'][k] for k in ('kappa', 'gain_over_PR4610', 'raw_root_interval', 'paid_calls', 'productive_fields')}}, sort_keys=True)) + + +if __name__ == '__main__': + main()