diff --git a/research/coded-compiler-closure/PROOF.md b/research/coded-compiler-closure/PROOF.md new file mode 100644 index 0000000000..002f15b1e4 --- /dev/null +++ b/research/coded-compiler-closure/PROOF.md @@ -0,0 +1,167 @@ +# A compiler instance conditional on the coded p19 inventory + +Apache-2.0. Cinna Davis with substantial OpenAI Codex assistance. + +## 1. Exact premise and conclusion + +Assume an all-column native program realizes **the independent Gaussian jobs** +and paid calls specified in Section 2, with the actual physical contracts needed +by the chronological product and finite integer compiler. This is a premise: +PR #4940's common-code model has no complete source-bound p19 physical replay. +Its physical code/frame mixing and odd-denominator implementation are separate +active investigations in Discussion #4930, comments 19139519 and 19139521. + +Under that premise, the credited higher-moment completion/splitting theorem +and logarithmic compiler give a strict uniform moment at complex saving +`0.0034 - 1/700000000`. The existing strict outer ledger accepts the planning +endpoint `0.00339999`, using the inherited admitted BIT saving 0.0034. +This proves a conditional compiler-arithmetic implication. It does not prove +the premise, admit a supplier, improve the selected K, or prove multiplication +faster. Fixed nonrecursive operations must still have the required physical, +precision and tape implementations. No unknown module is priced at zero. + +The source results used here are PR #4940's declared rank model; Dugongue's +PR #4929 native paid profile; the PR #4470 inventory/outer framework; and zxv's +PR #4433 higher-moment and logarithmic-majorant theorem. Their exact current +paths and immutable hashes are recorded in SOURCES.json. The core conditional +compiler argument is Sections 2--4 of +`research/higher-moment-strictification/README.md`; the selected p16 application +is Sections 5--6 of `research/joint-helper-lattice/PROOF.md`. + +## 2. Reconstructing every declared job + +There are 19 odd FULL stages 1,3,...,37 and 20 thin query stages 0,2,...,38. +Every FULL retains 408 independent helper jobs with profile +`H={4:28,7:7,8:47,9:326}` and pays the complete coded-native profile +`P0={1:2201,2:412,3:510,4:127,5:40}`. Both native orientation receipts agree +with P0; this check authenticates their recorded inventory and is not a fresh +632-column native replay. + +The full main pair has 224 owners of rank 153. The nine initial and nine terminal +pairs have 224 owners per pair. Each retained thick-stage count 1,...,9 occurs +twice, giving 448 main targets at each rank 9,17,...,73. The matched initial and +terminal IDLEs pay 448 calls at each rank 8,16,...,72. Middle IDLEs use even +stages and have zero retained rank. Every thin query pays 112 rank-one calls. +Thus + +``` +T = 224 H153 + 448 sum_{j=1}^9 H(1+8j) + 19 H, +P = 448 sum_{j=1}^9 H(8j) + 19 P0 + 2240 H1. +``` + +This totals 12008 productive fields and 68782 paid calls. Their rank masses +are 265533 and 263517, with surplus 2016. The verifier independently reconstructs +the interval census and compares every histogram entry against the exact +`invoice` function of PR #4940, extracted without running its experiments. +Deleting the 2240 thin-query children fails that equality. No coded owner is +silently recounted as a Gaussian job: that identification is the explicit +unproved premise in Section 1. + +## 3. Paid completion and splitting + +Take `C=17/5000`, `t=1-C`, `u=1/5`, cutoff 20, productive floor 21 and +tensor power `v=128`. Let `T_s=sum_r T_r r^s`, and similarly P_s. The +source higher-moment construction charges both padding short productive jobs +and splitting large paid jobs. Its ratios are + +``` +alpha = P_t/T_t, +gamma = P_(t+u)/(20^u T_t), +delta = 21 (# productive fields)/(20^C T_t). +``` + +Two separate exact rational interval evaluations certify + +``` +alpha < 249/250, +gamma < 97/100, +delta < 97/100. +``` + +The first is the credited 192-bit outward grid engine. The second uses the +separate positive logarithm/exponential series engine, with outward decimal +rounding at 10^-40 and range reduction before exponentiation. Their unrounded +intervals intersect, and each independently proves the strict inequalities. +No floating arithmetic is used for acceptance. + +The exact block inequality `(97/100)^128 < 1/16` and Bernoulli give the +fully charged normalized paid bound + +``` +alpha^128 + 2 gamma^128 + 2 delta^128 + < 1/(1+128/250) + 4 (97/100)^128 + < 125/189 + 1/4 = 689/756 < 1. +``` + +The actual rational bound is about 0.742442264862. Every small target is +completed on its own existing arbitrary input; the new axes create no new +productive owner. Every oversized paid child is split with its rounding +surcharge. The strict integer inequality `20^64 < 21^63` separates the +resulting paid and target ranks. The 128-fold chronological product has ambient +`153^128`, paid rank at most `20^128` and target rank at least `21^128`. +No product word is materialized. The same conservative bound exceeds one +at 64 copies; this is a control, not a minimality claim for tensor power 128. + +## 4. Logarithmic compiler capacity and effective rank + +Apply the retained finite integer compiler and its normalized leaf-count +majorant with `theta_bar=63/64` and logarithm power 140. The exact conditions are + +``` +2 (20^128)^64 <= (153^128)^63, +eta = (1-C) 153^(-128 C) > (63/64)^140, +153^(128 C) < 2^140. +``` + +Both interval engines certify eta in +`(0.111620296585564378680783225123, + 0.111620296585564378680783225124)`. +At these fixed theta and tensor power, 139 fails the eta condition and 140 +passes. This is not a global optimum over compiler parameters. + +The logarithmic-majorant theorem yields +`L(n) <= n^t (1+log2 n)^140` for integer n>=1 under its stated compiler +premises. This is a normalized recursive leaf-count bound, not a full running +time or precision/storage bound. The source induction uses no unknown +multiplicative constant in this particular majorant. + +The desired uniform saving is `C-d`, with `d=1/700000000`. On the grid +`H=700000000 j`, the sufficient integer-height comparison is + +``` +(700000000 j + 1)^140 < 2^j. +``` + +The first successful positive integer is j=5867, giving H=4106900000000; +j=5866 fails. Exact integer arithmetic establishes both comparisons. The +function `j ln(2) - 140 ln(700000000 j+1)` is strictly convex, initially +decreasing, and eventually increasing, so it has a single positive crossing. +The encoded uniform ambient rank is `N=2^H`; the word is algorithmically +specified under the compiler premises and is not emitted. + +This also reproduces the missing-budget warning: at `v=1024` and logarithm +power 1000, `(1-C)153^(-1024 C) < (63/64)^1000`. Reusing those constants fails +the capacity test. The changed 128/140 instance clears it. + +## 5. Strict outer arithmetic and remaining obligations + +Set planning `k=0.00339999`, `d=1/700000000`, tested complex saving `k+7d=C`, +uniform complex saving `k+6d`, `b=k+5d`, `a=k+4d`, `q=k+3d`, +`epsilon=1-d`, `beta=1-3d`, `r0=d/10`, and `stop=layout=d`. +Retain the admitted BIT saving 17/5000 and its atom exponent 1/250. +Every one of the 54 named strict predicates and 4 functional guards is positive, +including all nine outer cost rows. The fourth guard records the actual +source BIT atom in addition to the three historical ledger guards. + +The exact BIT-cap endpoint 0.0034 fails strict BIT headroom. The old BIT +admission, a closed uniform exponent gap and epsilon=1 each fail their named +guards. These controls prevent replacing strict inequalities with limits. + +The unresolved obligations remain substantive: a correct all-width p19 coded +caller with independent Gaussian endpoints; its actual signed port charts and +raw dual; denominator 13 rounding and error propagation; independent helper +returns and owned temporary cleanup; full scalar/address routing, physical +storage and precision costs; the ordinary BIT premises; and retained compiler, +analytic, prime-avoidance and exact-recovery contracts. This arithmetic package +does not fill any of those gaps. Passing it determines that the stated +compiler arithmetic need not be the limiting obstruction if they are closed. diff --git a/research/coded-compiler-closure/README.md b/research/coded-compiler-closure/README.md new file mode 100644 index 0000000000..8f14ae9c3a --- /dev/null +++ b/research/coded-compiler-closure/README.md @@ -0,0 +1,87 @@ +# Compiler reserve for the declared coded p19 inventory + +**Exact conditional arithmetic; no new admitted K.** PR #4940 leaves its changed +inventory's finite compiler constants unverified. This package supplies one +strict instance: 128 chronological copies, logarithm power 140, and the complete +54+4 outer predicates at the planning endpoint 0.00339999. The physical p19 coded +caller, its Gaussian target identification and its nonrecursive implementation +remain prerequisites. + +The result resolves only PR #4940's third open question at the level of its +declared rank model. Its first two questions, physical frame/code binding and +denominator 13 arithmetic, are under separate active claims in +[Discussion #4930](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930). +No native replay, p19 operator synthesis, supplier admission, selected-frontier +change or multiplication theorem is claimed. + +| Certified quantity | Value | +| --- | --- | +| Raw declared ambient rank | 153 | +| Thick calls / paid thin queries | 19 / 20 | +| Independent targets / paid calls | 12008 / 68782 | +| Tested complex saving | 17/5000 = 0.0034 | +| Completion/splitting tensor power | 128 | +| Maximum paid / minimum target rank | 20^128 / 21^128 | +| Normalized paid upper bound | less than 0.742442264862 | +| Logarithm power / theta bound | 140 / 63/64 | +| Uniform complex saving | 0.0034 minus 1/700000000 | +| Sufficient compiler rank encoding | 2^4106900000000 | +| Strict outer planning endpoint | 0.00339999 | + +[PROOF.md](PROOF.md) derives the entire conditional implication and the +inventory. [RESULT.json](RESULT.json) contains the exact source-bound receipt, +two separate rational interval evaluations, all outer predicates and failed +semantic controls. The inherited 1024/1000 capacity test fails; 140 is the least +passing logarithm power at the stated 128 copies and theta 63/64. No global +parameter optimum, practical template size or full runtime bound is asserted. + +From the repository root, with Python 3.12 and no extra dependencies: + +```sh +python3.12 -B scripts/research_package.py --package research/coded-compiler-closure +python3.12 -I -O -B research/coded-compiler-closure/verify.py +``` + +Direct replay authenticates all live inputs and is read-only. The optional +`--write` switch regenerates the arithmetic receipt. All live dependencies +are declared in VERIFY.json; the official exporter can create a self-contained +Git-free replay. No Lean, Docker, full selected replay or historical test suite +is required by this package. + +The investigation started at canonical main `f259dabc7d70e0db8d6d36bfda888f008bbfecc1`, +priority revision 7, selected conditional K 0.00302015. The canonical scoped claim +is [Discussion #4930 comment 19139629](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19139629). +Entry overlap covered 305 open PRs, 4126 Discussion records and all 6710 tracked +local research notes. This bounded search excludes arbitrary diffs and +unpublished work. Exact source hashes and historical selection/catalogue +provenance are in SOURCES.json; the changed scope is recorded in TASK.json. + +## Open next questions + +- Can the actual signed p19 physical caller realize every independent Gaussian + target in this invoice? Start with the already claimed source-bound local + backward/thin pair at comment 19139519 before extending a complete word. + The formal scalar-code conjugation does not prove that physical binding. +- Can its inverse recoding and full nonrecursive operations meet the retained + precision, storage and tape ABI? Bind the denominator 13 kernel claimed at + comment 19139521 to an actual recoding and its source-ordered error maps. + Local exact rational arithmetic is insufficient for rounded recursive work. + +TASK.json records the relevance, first step and blockers for each question. +Further compiler parameter scans do not resolve these physical obligations. + +## Credit + +SethBurkart123 supplies PR #4940's coded-reverse controller model and the open +compiler question. Dugongue/mdumitrean supplies PR #4929's center-free native +profile. Dillon's PR #4933 supplies the physical coded interface and explicit +unresolved target obligations. Cinna Davis's PR #4440/4470 supplies the retained +query-thinned construction, and Cao Yifan/intqwq supplies the PR #4610 native +word. The higher-moment and logarithmic-majorant theorem and first interval +engine are zxv's PR #4433; the second interval engine retains zxv's source +credit. Integer mixed flow is Jacob Alan Sussman's; the outer framework +retains all its original contributors. Source archives remain unchanged. + +New work prepared by Cinna Davis with substantial OpenAI Codex assistance in +derivation, verification and writing. Apache-2.0. No subagents, independent +human review or proof-kernel acceptance were used or claimed. diff --git a/research/coded-compiler-closure/RESULT.json b/research/coded-compiler-closure/RESULT.json new file mode 100644 index 0000000000..790e1ac628 --- /dev/null +++ b/research/coded-compiler-closure/RESULT.json @@ -0,0 +1,221 @@ +{ + "ambient_rank": 153, + "compiler": { + "eta": { + "lower": "0.111620296585564378680783225123", + "upper": "0.111620296585564378680783225124" + }, + "gap": "1/700000000", + "height": 4106900000000, + "integer_test_exponent": 5867, + "logarithm_power": 140, + "rank_encoding": "2^4106900000000", + "theta": "63/64", + "word_materialized": false + }, + "independent_intervals": { + "alpha": { + "lower": "0.995794145897384670549075464358", + "upper": "0.995794145897384670549075464359" + }, + "delta": { + "lower": "0.951560610482953560150021012929", + "upper": "0.951560610482953560150021012930" + }, + "eta": { + "lower": "0.111620296585564378680783225123", + "upper": "0.111620296585564378680783225124" + }, + "gamma": { + "lower": "0.963763314768449216656299278725", + "upper": "0.963763314768449216656299278726" + } + }, + "native_thick_calls": 19, + "negative_controls": { + "BIT_cap": [ + "actual_bit_above_effective" + ], + "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" + ], + "inherited_1024_1000": "eta below theta^1000", + "old_BIT": [ + "actual_bit_above_effective" + ], + "omit_twenty_queries": "inventory mismatch, 2240 H1 missing", + "tensor64_same_bounds": "charged tail bound exceeds one" + }, + "new_admitted_kappa": null, + "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": "416499474405001/122500000000000000", + "fused_gaussian": "416499473215003/122500000000000000", + "global_coordinate_router": "2379997/700000000", + "group_bit_router": "1665998592860009/490000000000000000", + "group_scans": "349999999/350000000", + "main_transform": "416499299405001/122500000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "50182124474405001/122500000000000000" + }, + "parameters": { + "a": "2379997/700000000", + "b": "1189999/350000000", + "beta": "699999997/700000000", + "bit_saving": "17/5000", + "cap_xi": "111432124299405001/122500000000000000", + "complex_uniform_saving": "2379999/700000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "339999/100000000", + "lambda_": "199320001/200000000", + "lambda_prime": "174405001/175000000", + "layout": "1/700000000", + "q": "594999/175000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "17/5000" + }, + "strict_checks": { + "actual_bit_above_effective": "3/700000000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "11067875963094999/61250000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "699405001/122500000000000000", + "cap_above_band": "50182124299405001/122500000000000000", + "cap_below_cell": "11067875525594999/122500000000000000", + "cap_below_phase_cell_power": "133567875700594999/122500000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "9747501/350000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "698215003/122500000000000000", + "gaussian_above_main": "86905001/61250000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "3492860009/490000000000000000", + "group_gauge_power_slack": "11067875954344999/61250000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "139524001/140000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "834509790400418148631/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": "698810001/245000000000000000", + "leaf_saving_above_effective": "348810001/245000000000000000", + "main_transform_above_kappa": "524405001/122500000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "53897620011/700000000", + "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": "348810003/350000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "698810001/245000000000000000", + "q_positive": "594999/175000000", + "short_record_fallback": "348810001/350000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "49765625699405001/122500000000000000", + "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": 44059, + "16": 448, + "2": 7828, + "24": 448, + "3": 9690, + "32": 448, + "4": 2413, + "40": 448, + "48": 448, + "5": 760, + "56": 448, + "64": 448, + "72": 448, + "8": 448 + }, + "paid_count": 68782, + "pairs": 19, + "planning_outer_endpoint": "339999/100000000", + "prerequisites": [ + "An all-width p19 physical coded caller realizes exactly this independent Gaussian inventory.", + "Physical code/phase charts, inverse recoding, odd division and all helper returns are valid.", + "Nonrecursive routing, owned storage, precision and fixed-tape work meet the retained ABI.", + "The source ordinary BIT, integer compiler, analytic and exact-recovery premises apply." + ], + "raw_rank_mass_surplus": 2016, + "scope": "Conditional compiler/outer arithmetic. No native replay, p19 physical word, supplier admission, selected update, or multiplication theorem.", + "status": "PASS_CODED_P19_COMPILER_ARITHMETIC_ONLY", + "strictification": { + "alpha": { + "lower": "0.995794145897384670549075464358", + "upper": "0.995794145897384670549075464359" + }, + "cutoff": 20, + "delta": { + "lower": "0.951560610482953560150021012929", + "upper": "0.951560610482953560150021012930" + }, + "floor": 21, + "gamma": { + "lower": "0.963763314768449216656299278725", + "upper": "0.963763314768449216656299278726" + }, + "normalized_paid_upper": { + "lower": "0.742442264861864979700485167940", + "upper": "0.742442264861864979700485167941" + }, + "simple_upper_bound": "689/756", + "tail_offset": "1/5", + "tensor_power": 128 + }, + "target_count": 12008, + "targets": { + "153": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 532, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 133, + "73": 448, + "8": 893, + "9": 6642 + }, + "tested_complex_saving": "17/5000", + "thin_queries": 20, + "uniform_complex_saving": "2379999/700000000" +} diff --git a/research/coded-compiler-closure/SOURCES.json b/research/coded-compiler-closure/SOURCES.json new file mode 100644 index 0000000000..af82272e70 --- /dev/null +++ b/research/coded-compiler-closure/SOURCES.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "base_commit": "f259dabc7d70e0db8d6d36bfda888f008bbfecc1", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/PHYSICAL.md", + "usage": "input", + "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f", + "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078" + }, + { + "path": "research/coded-reverse-controller/README.md", + "usage": "input", + "git_blob": "998410d16e16fefc6de982edfd1496f315146a4a", + "sha256": "f7bb9a2ba49cf7efa87fd68cc2d095e0ddff458f1360e504a2b16cf5caaa8d46" + }, + { + "path": "research/coded-reverse-controller/verify.py", + "usage": "input", + "git_blob": "71f3d8929f28d7b4b854be7177ca8dfecf81ea5c", + "sha256": "05a898d3af329dc4665590b4ec4b2801e588843efe9618eec55b4028fd104b67" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/joint-helper-lattice/PROOF.md", + "usage": "input", + "git_blob": "e41106031da41fade7a7419c17a32c1bd9aa103b", + "sha256": "43ef4251cc300f1b18cbe8cdb060f96f95748e6797d2478b4c04b79a8373ef91" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/native-center-free-code/EXPECTED.json", + "usage": "input", + "git_blob": "b02b5ebb8b7482bf733744507095e37045c0ff83", + "sha256": "e147122a93e3c2c5f78af42b631e1fb9410178987b9cc4ca6b5c63a5cb9dccc8" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/joint-helper-lattice/RESULT.json", + "usage": "input", + "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596", + "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21" + } + ] +} diff --git a/research/coded-compiler-closure/TASK.json b/research/coded-compiler-closure/TASK.json new file mode 100644 index 0000000000..75fb0a4874 --- /dev/null +++ b/research/coded-compiler-closure/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "f259dabc7d70e0db8d6d36bfda888f008bbfecc1", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. 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", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Resolve PR4940 open question3: strictification, finite logarithmic compiler and complete outer arithmetic for its declared p19 coded inventory; all-width physical realization remains a prerequisite.", + "scope_change_reason": "The user explicitly requests structural progress toward larger K. Existing PR4940 hands off this exact compiler obligation; distinct active claims cover physical pair binding and denominator13 arithmetic. The random verifier-engineering suggestion is not adopted because it would not address that missing K-oriented obligation.", + "bottleneck_link": "Determine whether the changed center-free paid inventory can clear uniform compilation and the complete outer transfer near the BIT cap, rather than treating a favorable raw moment as an admitted saving.", + "budget_minutes": 60, + "stop_rule": "One p19 inventory and exact compiler instance only. Stop if inventory equality, either paid tail, shifted capacity, integer crossing or an outer guard fails. Do not launch native synthesis or count unknown physical costs as zero.", + "outcome": "partial", + "evidence": "PROOF.md and RESULT.json: exact arithmetic under explicitly unproved physical caller prerequisites. No new admitted kappa.", + "author": "Cinna Davis with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, code and writing; no subagents used.", + "open_questions": [ + { + "question": "Does the actual signed, frame-dependent p19 caller realize every Gaussian target in this invoice?", + "why_it_matters": "Compiler arithmetic cannot admit the coded outputs as independent Gaussian jobs.", + "first_step": "Use the physical-pair claim in Discussion4930 comment19139519; require exact phase and arbitrary-input equality before extending beyond that pair.", + "blocked_by": "Unproved physical code/frame substitution; no complete p19 native caller replay." + }, + { + "question": "Can inverse recoding and all nonrecursive work meet the retained precision/tape ABI?", + "why_it_matters": "Odd-denominator rounding, routing and storage are real work even when there are no extra recursive Gaussian children.", + "first_step": "Bind the denominator13 kernel claimed at Discussion4930 comment19139521 to one actual physical recoding and its source-ordered error maps.", + "blocked_by": "Complete caller ledger, helper returns, finite precision, movement and uniform ABI admission." + } + ] +} diff --git a/research/coded-compiler-closure/VERIFY.json b/research/coded-compiler-closure/VERIFY.json new file mode 100644 index 0000000000..6db06b840a --- /dev/null +++ b/research/coded-compiler-closure/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coded-native-caller/PHYSICAL.md", + "research/coded-reverse-controller/README.md", + "research/coded-reverse-controller/verify.py", + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/joint-helper-lattice/PROOF.md", + "research/joint-helper-lattice/RESULT.json", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/native-center-free-code/EXPECTED.json", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "source-bound p19 rank inventory, two separate exact interval engines, both paid tails, logarithmic compiler capacity and adjacent integer crossing, all54+4 strict outer predicates and semantic controls" + } + ] +} diff --git a/research/coded-compiler-closure/verify.py b/research/coded-compiler-closure/verify.py new file mode 100644 index 0000000000..108156e97f --- /dev/null +++ b/research/coded-compiler-closure/verify.py @@ -0,0 +1,272 @@ +#!/usr/bin/env python3 +"""Compiler arithmetic conditional on PR4940's declared p19 inventory. + +No physical coded caller is admitted. Apache-2.0. Cinna Davis with substantial +OpenAI Codex assistance. The interval engines, strictification and outer ledger +retain their source attribution. +""" +import argparse +import ast +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +TESTED, PLANNING_KAPPA = Q(17, 5000), Q(339999, 100000000) +V, LOG_POWER, THETA = 128, 140, Q(63, 64) +NATIVE = {1: 2201, 2: 412, 3: 510, 4: 127, 5: 40} +HELPERS = {4: 28, 7: 7, 8: 47, 9: 326} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, ROOT / path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def authenticate(): + for row in json.loads((HERE / 'SOURCES.json').read_text())['files']: + if row['usage'] == 'input': + path = ROOT / row['path'] + need(not path.is_symlink(), 'Source symlink: ' + row['path']) + need(sha256(path.read_bytes()).hexdigest() == row['sha256'], + 'Changed source: ' + row['path']) + + +def source_invoice(): + """Evaluate only the pinned rank model, without its discovery experiments.""" + path = ROOT / 'research/coded-reverse-controller/verify.py' + tree = ast.parse(path.read_text(), filename=str(path)) + assignments = {n.targets[0].id: ast.literal_eval(n.value) + for n in tree.body if isinstance(n, ast.Assign) + and isinstance(n.targets[0], ast.Name) + and n.targets[0].id in ('H', 'P_NEW')} + need(assignments == {'H': HELPERS, 'P_NEW': NATIVE}, 'Pinned source profiles') + node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) + and n.name == 'invoice') + env = {'Counter': Counter, 'H': assignments['H']} + exec(compile(ast.Module(body=[node], type_ignores=[]), str(path), 'exec'), env) + return env['invoice'](19, 'I' * 9 + 'T' * 9, + frozenset(range(1, 38, 2)), assignments['P_NEW']) + + +def inventory(): + """Census intervals independently of the source invoice function.""" + targets, paid = Counter({153: 224}), Counter({1: 20 * 112}) + thick = set(range(1, 38, 2)) + for pair in range(1, 19): + if pair <= 9: + output, idle = range(0, 2 * pair + 1), range(0, 2 * pair) + else: + output, idle = range(2 * pair, 39), range(2 * pair + 1, 39) + targets[1 + 8 * len(thick.intersection(output))] += 224 + paid[8 * len(thick.intersection(idle))] += 224 + need(not any(2 * j in thick for j in range(1, 19)), 'Middle IDLEs have zero rank') + targets.update({r: 19 * n for r, n in HELPERS.items()}) + paid.update({r: 19 * n for r, n in NATIVE.items()}) + need((targets, paid) == source_invoice(), 'Independent/source inventory equality') + receipt = json.loads((ROOT / 'research/native-center-free-code/EXPECTED.json').read_text()) + need(all({int(k): v for k, v in run['paid'].items()} == NATIVE + for run in receipt['runs']), 'Both retained native orientations') + selected = json.loads((ROOT / 'research/joint-helper-lattice/RESULT.json').read_text()) + need({int(k): n for k, n in selected['local_helpers'].items()} == HELPERS, + 'Source productive-helper inventory') + need(sum(targets.values()) == 12008 and sum(paid.values()) == 68782, + 'All independent targets and paid calls counted') + need(sum(r * n for r, n in targets.items()) == 265533 + and sum(r * n for r, n in paid.items()) == 263517, 'Raw mass census') + return targets, paid + + +def independent_power(engine, rank, exponent): + """Positive-series enclosure with rational endpoints, separate from the grid engine.""" + grid = 10 ** 40 + + def rounded(a, b): + return Q((a * grid).__floor__(), grid), Q((b * grid).__ceil__(), grid) + + if rank == 1 or exponent == 0: + return Q(1), Q(1) + low, high = engine.log_interval(rank) + low, high = rounded(low * abs(exponent), high * abs(exponent)) + squares = 0 + while high >= Q(1, 2): + low /= 2 + high /= 2 + squares += 1 + a, b = rounded(engine.exp_interval(low)[0], engine.exp_interval(high)[1]) + for _ in range(squares): + a, b = rounded(a * a, b * b) + return (1 / b, 1 / a) if exponent < 0 else (a, b) + + +def independent_checks(engine, E, targets, paid, ratios, eta): + def moment(histogram, exponent): + values = [(n, independent_power(engine, r, exponent)) + for r, n in histogram.items()] + return tuple(sum(n * interval[i] for n, interval in values) for i in (0, 1)) + + def divide(a, b): + return a[0] / b[1], a[1] / b[0] + + t = 1 - TESTED + target = moment(targets, t) + alpha = divide(moment(paid, t), target) + cut = independent_power(engine, 20, Q(1, 5)) + gamma = divide(moment(paid, t + Q(1, 5)), + (cut[0] * target[0], cut[1] * target[1])) + cut = independent_power(engine, 20, TESTED) + delta = divide((Q(21 * sum(targets.values())),) * 2, + (cut[0] * target[0], cut[1] * target[1])) + base = independent_power(engine, 153, -V * TESTED) + independent_eta = ((1 - TESTED) * base[0], (1 - TESTED) * base[1]) + for label, a, b in [('alpha', alpha, ratios[0]), ('gamma', gamma, ratios[1]), + ('delta', delta, ratios[2]), ('eta', independent_eta, eta)]: + need(max(a[0], b[0]) <= min(a[1], b[1]), 'Independent enclosure: ' + label) + need(alpha[1] < Q(249, 250) and gamma[1] < Q(97, 100) + and delta[1] < Q(97, 100) and independent_eta[0] > THETA ** LOG_POWER, + 'Independent strictification and capacity') + return {name: E.display(x) for name, x in + [('alpha', alpha), ('gamma', gamma), ('delta', delta), ('eta', independent_eta)]} + + +def height(step, power): + def passes(j): + return (step * j + 1) ** power < 2 ** j + lo, hi = 1, 2 + while not passes(hi): + lo, hi = hi, 2 * hi + while hi - lo > 1: + mid = (lo + hi) // 2 + if passes(mid): + hi = mid + else: + lo = mid + need(passes(hi) and not passes(hi - 1), 'Adjacent integer-height crossing') + return hi, step * hi + + +def parameters(kappa): + gap = Q(1, 700000000) + return {'kappa': kappa, 'tested_saving': kappa + 7 * gap, + 'complex_uniform_saving': kappa + 6 * gap, 'b': kappa + 5 * gap, + 'a': kappa + 4 * gap, 'q': kappa + 3 * gap, 'bit_saving': Q(17, 5000), + 'epsilon': 1 - gap, 'beta': 1 - 3 * gap, 'r0': gap / 10, + 'stop': gap, 'layout': gap, 'd': gap} + + +def outer_ledger(L, params): + out = L.ledger(params) + out['functional_checks']['actual_new_BIT_stock_sublinear'] = params['beta'] * Q(249, 250) + return out + + +def failed(out): + return [name for part in ('strict_checks', 'functional_checks') + for name, value in out[part].items() if value <= 0] + + +def run(): + authenticate() + targets, paid = inventory() + E = load('research/higher-moment-strictification/verify.py', 'coded_compiler_intervals') + other = load('research/kappa-rebuild/architecture/mixed_target_probe.py', + 'coded_compiler_separate_intervals') + L = load('research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py', + 'coded_compiler_outer') + t = 1 - TESTED + target = E.moment(targets, t) + alpha = E.divide(E.moment(paid, t), target) + gamma = E.divide(E.moment(paid, t + Q(1, 5)), E.mul(E.power(20, Q(1, 5)), target)) + delta = E.divide((Q(21 * sum(targets.values())),) * 2, + E.mul(E.power(20, TESTED), target)) + need(alpha[1] < Q(249, 250) and gamma[1] < Q(97, 100) + and delta[1] < Q(97, 100), 'All three charged tail bounds') + need(Q(97, 100) ** V < Q(1, 16), 'Exact 128-copy decay block') + bound = 1 / (1 + Q(V, 250)) + 4 * Q(97, 100) ** V + need(bound < Q(689, 756) < 1 and 20 ** 64 < 21 ** 63, + 'Paid completion, splitting and separation') + eta = E.scale(E.power(153, -V * TESTED), t) + need(2 * 20 ** (64 * V) <= 153 ** (63 * V), 'Shifted exit inequality') + need(eta[0] > THETA ** LOG_POWER and eta[1] < THETA ** (LOG_POWER - 1), + 'Logarithmic power140 passes and139 fails at v128') + need(E.power(153, V * TESTED)[1] < 2 ** LOG_POWER, 'Ordinary compiler base range') + independent = independent_checks(other, E, targets, paid, (alpha, gamma, delta), eta) + params = parameters(PLANNING_KAPPA) + gap = TESTED - params['complex_uniform_saving'] + need(gap == Q(1, 700000000) and params['tested_saving'] == TESTED, 'Compiler gap grid') + j, H = height(gap.denominator, LOG_POWER) + need(H > 8 * V, 'Uniform ambient exceeds the product ambient') + outer = outer_ledger(L, params) + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4 + and not failed(outer), 'Complete 54+4 strict outer ledger') + controls = {} + half = E.power(153, -512 * TESTED) + old_eta = E.scale(E.mul(half, half), t) + need(old_eta[1] < THETA ** 1000, 'Inherited 1024/1000 capacity must fail') + controls['inherited_1024_1000'] = 'eta below theta^1000' + too_small = 1 / (1 + Q(64, 250)) + 4 * Q(97, 100) ** 64 + need(too_small > 1, 'Same conservative tail bound fails at64 copies') + controls['tensor64_same_bounds'] = 'charged tail bound exceeds one' + altered = Counter(paid) + altered[1] -= 20 * 112 + need((targets, altered) != source_invoice(), 'Dropping the thin queries rejected') + controls['omit_twenty_queries'] = 'inventory mismatch, 2240 H1 missing' + for name, patch in [('BIT_cap', {'kappa': TESTED}), + ('old_BIT', {'bit_saving': Q(27, 10000)}), + ('closed_uniform', {'complex_uniform_saving': params['b']}), + ('closed_epsilon', {'epsilon': Q(1)})]: + bad = parameters(TESTED) if name == 'BIT_cap' else dict(params, **patch) + failures = failed(outer_ledger(L, bad)) + need(bool(failures), 'Rejected outer control: ' + name) + controls[name] = failures + return E.encoded({ + 'status': 'PASS_CODED_P19_COMPILER_ARITHMETIC_ONLY', + 'new_admitted_kappa': None, 'planning_outer_endpoint': PLANNING_KAPPA, + 'tested_complex_saving': TESTED, 'uniform_complex_saving': params['complex_uniform_saving'], + 'native_thick_calls': 19, 'thin_queries': 20, 'pairs': 19, 'ambient_rank': 153, + 'targets': dict(sorted(targets.items())), 'paid': dict(sorted(paid.items())), + 'target_count': sum(targets.values()), 'paid_count': sum(paid.values()), + 'raw_rank_mass_surplus': 2016, + 'strictification': {'tensor_power': V, 'cutoff': 20, 'floor': 21, 'tail_offset': Q(1, 5), + 'alpha': E.display(alpha), 'gamma': E.display(gamma), + 'delta': E.display(delta), 'normalized_paid_upper': E.display((bound, bound)), + 'simple_upper_bound': Q(689, 756)}, + 'compiler': {'theta': THETA, 'logarithm_power': LOG_POWER, 'eta': E.display(eta), + 'gap': gap, 'integer_test_exponent': j, 'height': H, + 'rank_encoding': '2^' + str(H), 'word_materialized': False}, + 'independent_intervals': independent, 'outer': outer, 'negative_controls': controls, + 'prerequisites': [ + 'An all-width p19 physical coded caller realizes exactly this independent Gaussian inventory.', + 'Physical code/phase charts, inverse recoding, odd division and all helper returns are valid.', + 'Nonrecursive routing, owned storage, precision and fixed-tape work meet the retained ABI.', + 'The source ordinary BIT, integer compiler, analytic and exact-recovery premises apply.' + ], + 'scope': 'Conditional compiler/outer arithmetic. No native replay, p19 physical word, supplier admission, selected update, or multiplication theorem.' + }) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + result = run() + path = HERE / 'RESULT.json' + if args.write: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(path.read_text()) == result, 'Committed arithmetic receipt') + print(result['status'], 'height=' + str(result['compiler']['height']), 'no_new_kappa')