diff --git a/research/bit-compact-productive-controller/PRICE-PROPOSAL.json b/research/bit-compact-productive-controller/PRICE-PROPOSAL.json new file mode 100644 index 0000000000..33f6059d57 --- /dev/null +++ b/research/bit-compact-productive-controller/PRICE-PROPOSAL.json @@ -0,0 +1,99 @@ +{ + "invoice": { + "targets": { + "4": 72, + "8": 7776, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "127": 222 + }, + "paid": { + "1": 25407, + "2": 24156, + "3": 1404, + "4": 702, + "5": 1836, + "6": 180, + "7": 324, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444, + "63": 222 + }, + "rank_surplus": 753, + "thick_calls": 18, + "thin_queries": 1665, + "original_fields": 11400, + "main_original_fields": 3552, + "helper_original_fields": 7848 + }, + "certificate": { + "params": { + "tested": "69509/20000000", + "uniform": "43443/12500000", + "cover_gap": "9765881/2560000000000", + "atom": "173/50000", + "admitted": "34597/10000000", + "old_backend": "384599/10000000000", + "alpha_gap": "1/4294967296", + "prime_coefficient": 67108864 + }, + "after_cover": "8887360519/2560000000000", + "ordinary_exact": "17713901828029/5120000000000000", + "admitted": "34597/10000000", + "tail": { + "tested_saving": "69509/20000000", + "uniform_saving": "43443/12500000", + "alpha": { + "lower": "0.999999991905059684301510340131", + "upper": "0.999999991905059684301510340132" + }, + "gamma": { + "lower": "0.958113118679772899937220732700", + "upper": "0.958113118679772899937220732701" + }, + "delta": { + "lower": "0.948389236578657043633140116103", + "upper": "0.948389236578657043633140116104" + }, + "tensor_power": 1024, + "cutoff_base": 17, + "target_floor_base": 18, + "tail_exponent": "1/5", + "normalized_surplus_lower": "1069547519/4503600701112320", + "compiler_H0": 377227157504, + "uniform_H1": 262206447682297857, + "uniform_N": "2^262206447682297857", + "winning_word_materialized": false + }, + "comparators": { + "current_admitted": "17/5000", + "current_exact_ordinary": "8590884599/2500000000000", + "PR4697_fixed_C0_prime_saturated_sup": "8845274375/2568746817031" + }, + "relative_gains": { + "current_admitted": "597/34000", + "current_exact_ordinary": "58365401/8590884599", + "PR4697_fixed_C0_prime_saturated_sup": "418189878821507/88452743750000000" + }, + "margins": { + "adapter": "1298171971/5120000000000000", + "ordinary_relaxation": "237828029/5120000000000000", + "stock": "5084570898171971/5120000000000000", + "prime_allowance": "17179869184/9765881" + }, + "WORD_changed": true, + "new_whole_kappa": null, + "scope": "Conditional ordinary BIT supplier only; main selected/complex result unchanged." + } +} \ No newline at end of file diff --git a/research/bit-compact-productive-controller/PROOF.md b/research/bit-compact-productive-controller/PROOF.md new file mode 100644 index 0000000000..fef2f89525 --- /dev/null +++ b/research/bit-compact-productive-controller/PROOF.md @@ -0,0 +1,218 @@ +# Compact partial-helper BIT supplier + +This is a conditional ordinary BIT improvement. All analytic, exact-recovery, +physical-tape, all-size native/compiler and fixed-weight assumptions of the +selected construction are retained. The selected multiplication exponent is +unchanged. This package supplies a changed finite native unit, its complete +paid mixed-target bill, and fresh strictification and ordinary parameters. + +## 1. The local interface + +The input is the already merged compact436 word from #4326 and its retained +predecessor lineage. No new local rewrite is claimed. Its 658 original ARRAYs +are 111 main SOURCEs, 111 main receivers and 436 arbitrary independent helpers. +All helpers start in frame zero. The nine owned COPY lifetimes use one temporary +slot, charged at rank seven, and return it safely; they add no productive input. + +Every MOVE changes an actual nested pair of rational QQ frames, with a proper +paid rank. Every signed VALUE addition uses a common actual frame. The complete +Boolean linear map on **all 658 original symbols** has own-input rows on the +SOURCEs and helpers and the required SOURCE addition on the main receivers. +The SOURCE entry/exit frames and receiver entry/exit frames are exactly those +of the PR589 primitive used by the selected controller. The signed programs +also compose with their actual inverses in both orders. + +The physical effect includes the endpoint frames. For a helper beginning at +zero, own-input VALUE row and final frame U imply the actual job D_H on that +arbitrary input, with + + H = B^T (B B^T)^(-1) B. + +432 helpers have H=I8. Roles 462,463,466,468 end at frames506,506,508,509, +respectively, and have actual rational rank-four idempotents H. They retain +their own arbitrary inputs without cross terms. Their output credit is four, +not eight. Their omitted full-rank completion would have projector I-H. + +The new local paid inventory is + + {1:1319, 2:1342, 3:78, 4:39, 5:102, 6:10, 7:18}. + +It includes all nine rank-seven COPY charges. The 19,071 unit additions and +all native source/frame conditions remain part of the unit. The fallback +`local_word.py --completed` pays four additional rank-four calls; it is not +the submitted partial-helper interface. + +## 2. Actual chronological p16 caller + +Retain the query-thinned p16,a7 scalar word, both physical boundaries, all15 +query-only stages, full idles and main port charts. At each of its18 full +invocations, substitute the new local word. It accepts arbitrary current +SOURCE/receiver data, so chronological composition permits correlations in +those values. Each invocation has its own436 fresh arbitrary helper owners. +The input count is + + 32*111 + 18*436 = 11,400. + +`global_word.py` emits446,400 chronological records. The separate interpreter +checks all11,400 decoded RAW columns, current frame states, injective helper +ownership, actual SOURCE versions and all1,827 owned lifetimes. The all-function +argument combines those checks with the exact main group-polynomial identity, +the local common-frame invariant and111 rational port-chart identities. +The polynomial identity is checked coefficient by coefficient, not at a few +character evaluations. The old LOCAL only changes the main receiver/shear +interface; its replacement has the identical interface. + +The active-stage injection uses the old eight-space plus17 distinct fresh +seven-spaces, within127 head coordinates. Thin stages allocate no helper bank. +Each main coefficient has its stated rank, so the complete productive inventory +is + + T={4:72,8:7776,15:444,22:444,29:444,36:444, + 43:444,50:444,57:444,64:222,127:222}. + +Every actual recursive call remains in + + P={1:25407,2:24156,3:1404,4:702,5:1836,6:180,7:324, + 14:444,21:444,28:444,35:444,42:444,49:444,56:444,63:222}. + +There are57,339 queries. The rank-one surplus is still753. This includes every +copied thin query and whole idle. All11,400 originals of the new supplier are +checked. Its54 fewer helper originals also lose their old output credit; +they are not omitted columns of an unchanged11,454-input program. +`audit_stream.py` independently reads the emitted records and +rejects duplicate owners, fake rank-eight credit, missing CLEAR, a wrong nested +residual and a SOURCE modification during a capture. + +## 3. Whole-job normalization and all column multiplicities + +Let Q4=diag(I4,0) on the local eight-space. Each special helper has explicit +image and kernel bases. With S=[B^T|A^T], exact arithmetic checks + + S Q4 S^(-1)=H, S^(-1) H S=Q4. + +The reversed-tail16-dimensional covariance is also checked. In physical +paired coordinates the matching matrix is diag(S,C8 S C8); its inverse +conjugates the actual D_H into D_Q4. Tensoring by I_f proves the identity for +every positive column multiplicity, using C_(8f)=C8 tensor Cf. + +Use the source delayed **whole-GL cover**, introduced after the finite word +has been compiled. For a raw H output the physical input fiber route is +g -> g S^(-1), with inverse return g -> g S. Both routes are paid. There are +72 such output jobs and144 additional routes. This protocol uses fresh +independent complete-cover rows and one common ancestor-only external weight; +it does not require a free dense operation on an uncovered ARRAY. The main +port routes and all SOURCE INDEX/lifetime conditions remain explicit. Only +final rank-one leaves use the inherited weighted normalization. + +Together with7,548 inherited nonidentity main port routes, the raw route +census is7,692. The finite full-group cover is algorithm-defined; it is not +materialized by these tests. Its legality retains the selected source's +whole-job and native implementation hypotheses. + +## 4. Strict price gain + +Write Phi(t)=sum_k T_k k^t - sum_r P_r r^t. One changed full invocation adds + + Delta(t)=4 + 3^t + 9*4^t + 6^t + 7^t - 7*8^t. + +The positive terms split seven eights into + + (1,7), (1,1,6), (1,3,4), (4,4), (4,4), (4,4), (4,4). + +Each group sums to eight. Strict subadditivity of x^t for00, while Delta(1)=0. This compares the two verified circuits' prices. +The complete p16 difference is18 Delta(t); main, query-only and idle terms +are unchanged. Independent exact intervals put the new raw crossing in + + (0.003475458064076428997514, 0.003475458064076428997515), + +against the old + + (0.003464248972023961106948, 0.003464248972023961106949). + +The raw improvement is about0.323565%. It is a changed paid/target inventory. + +## 5. Charged completion, splitting and finite rank compiler + +Rank-four targets overlap the large idle ranks. Apply the source chronological +tensor product and higher-moment theorem, retaining distinct physical owners, +whole-job normalizers and every live owned bank. Complete every product target +below18^1024 with a paid disjoint-axis job on that same owner, and split every +original and added paid job at17^1024. New input credit is never created by +completion. + +At C=0.00347545, t=1-C, u=1/5 and v=1024, use the complete bound + + alpha^v + 2 gamma^v + 2 delta^v, + alpha=P_t/T_t, + gamma=P_(t+u)/(17^u T_t), + delta=11400*18/(17^C T_t). + +Two retained rational interval engines and a separately implemented positive- +series engine verify alpha<1-2^-32, gamma<31/32 and delta<19/20. +Both latter bounds raised to128 are below1/16, and + + 1/(1+1024*2^-32) + 4*2^-32 < 1. + +Thus both tails, including all target completion, fit. The new uniform saving +before covering is C0=0.00347544. The source integer compiler inequalities, +with17^64<18^63 and raw ambient127<256, give + + H0=377227157504, + H1=262206447682297857, + N=2^H1. + +These are sufficient rank-compiler arithmetic bounds. They are not a claim +that the predecessor's numerical precision, tape or stock thresholds apply +unchanged to the new word. + +## 6. Cover, stock, finite constants and ordinary saving + +Set d=C0-C1=2^-18+10^-10, so + + C1=8887360519/2560000000000. + +The same odd-prime rule q>2^26 N^5, avoiding the fixed denominators and rank +witnesses, satisfies q>(256/d)N^5 and pays the full bad-class fallback. Fix +all new finite word, route, height and owned-bank lists before varying the +input chunk width e. The new raw cancellation-free integer prefix bound +uses485 bits; the old21-bit bound is not inherited. The bound10^9 is a coarse +raw-record allowance, not a final normalizer or machine-instruction count. +After tensoring, completion, splitting and finite compilation, regenerate +their fixed counts and heights by those source algorithms. In particular, +tensor/normalizer multipliers do not remain bounded by10^9. + +These fixed constants multiply the source lower-order adapter, old-atom and +ROW terms. The source proof permits this dependence on the fixed new +(N,B,q,program). No route or normalizer is assigned zero cost. The borrowed +reserve is the product W(w)^D S_old with + + W(w)=B |GL_N(F_q)| q^(N^2(w-1)), + D >= floor(log_N ceil(e/w)). + +Its borrowed digits are O_(N,B,q)(w log e). Choose atom exponent +rho=0.00346 and w=ceil(e^rho). With the retained old saving +a_old=0.0000384599, the three root costs are + + O(V[e^(1-rho) + +e^((1-rho)(1-C1)+rho(1-a_old)) + +e^rho log e]). + +Consequently the exact ordinary saving is + + a=(1-rho)C1+rho a_old + =17713901828029/5120000000000000. + +The exact positive gaps are + + rho-a=1298171971/5120000000000000, + 1-a-rho=5084570898171971/5120000000000000, + a-0.0034597=237828029/5120000000000000. + +They absorb the linear adapter and borrowed-stock logarithm for sufficiently +large e with the newly generated finite constants. This admits the simpler +ordinary BIT saving34597/10000000=0.0034597. The massive winning word and its +full machine execution are not materialized. This is the same conditional +native/compiler setting as the selected supplier, with the changed ABI and +new finite constants stated explicitly. No larger complex or multiplication +kappa follows from this BIT-only contribution. diff --git a/research/bit-compact-productive-controller/README.md b/research/bit-compact-productive-controller/README.md new file mode 100644 index 0000000000..d574ae72db --- /dev/null +++ b/research/bit-compact-productive-controller/README.md @@ -0,0 +1,114 @@ +# Ordinary BIT saving 0.0034597 with compact partial helpers + +This constructs a conditional ordinary BIT supplier with saving +**34597/10000000 = 0.0034597**. This admitted bound improves by about +**0.67939%** over the current exact 0.0034363538396 derivation. The selected +integer-multiplication κ remains **0.00302015**; the complex side still binds. + +The change ports the already published compact436 word (#4326) into the +current query-thinned p16 controller. Its four partial helper outputs become +actual independent rank-four jobs. Each full invocation retains432 rank-eight +helper jobs and four rank-four jobs, with the same main SOURCE/receiver ABI. +They all start on arbitrary independent data. The new interface avoids paying +four completions and uses the source's arbitrary-idempotent whole-job cover. +The local compact rewrite itself is a credited predecessor. + +| Quantity | Current p16 BIT | This supplier | +| --- | ---: | ---: | +| Original arbitrary fields | 11,454 | 11,400 | +| Paid recursive calls | 57,555 | 57,339 | +| Independent helper jobs | 7,902 × rank8 | 7,776 × rank8 + 72 × rank4 | +| Rank-one surplus | 753 | 753 | +| Raw crossing | 0.003464248972023961… | 0.003475458064076428… | +| Exact ordinary saving | 0.0034363538396 | 17713901828029 / 5120000000000000 | +| Admitted ordinary saving | 0.0034 | **0.0034597** | + +The raw crossing improves by **0.323565%**. Retuning the charged tensor tails, +delayed cover and atom conversion gives the stronger ordinary result. These +are exponent savings, without a claim about practical runtimes. Source pins +are in [SOURCES.json](SOURCES.json), the complete deterministic certificate in +[RESULT.json](RESULT.json), and the proposed scoped record in +[RECORD.json](RECORD.json). + +## Evidence and scope + +- Both local interpreters check all658 original Boolean columns, actual native + frames, proper paid queries and nine safe COPY leases. The primary local + interpreter additionally checks exact signed inverse compositions in both orders. +- The actual caller emits446,400 records. A separate emitted-stream interpreter + checks all11,400 decoded RAW columns,18 injective helper banks, every current + SOURCE version and1,827 paid private lifetimes. Exact physical main polynomial + coefficients and111 rational port charts complete the all-function binding. +- The four real rank-four projectors and image/kernel matchers are explicit. + Reversed-tail16D covariance is checked. The all-f identity is tensorial; + whole fiber routes, common external weight and caller INDEX conditions are + retained. There are144 new positive-cost matcher routes, plus7,548 inherited + nonidentity main port routes. +- All tensor completion and paid splitting charges are retained. Three exact + numerical implementations agree on the tails. The independently written + price audit reads the actual partial word and a committed primitive literal, + rather than importing the primary invoice or interval functions. +- Six local, five stream and four arithmetic corruption controls must reject. + Direct normal and optimized replays use explicit checks rather than assertions. + +[PROOF.md](PROOF.md) gives chronological substitution, mixed helper admission, +the strict concavity gain, full completion/splitting, finite rank-compiler +parameters, prime fallback and ordinary stock conversion. The new global +integer prefix bound is485 bits. Fresh fixed height, route, bank, stock and +precision constants must be generated from the changed finite program; old +numerical thresholds are not inherited. The10^9 allowance bounds raw symbolic +records, and is not a final normalized machine-instruction bound. + +This is a finite all-column native schematic plus a conditional ordinary BIT +construction under the retained native/all-size compiler, tape and analytic +interfaces. The astronomical uniform word and full machine execution are +algorithm-defined and were not materialized. No complete multiplication +theorem, selected-frontier promotion or independent human review is claimed. + +## Reproduce + +Standard library only, Python3.12 or later, from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/bit-compact-productive-controller --check-only +python3 -B scripts/research_package.py --package research/bit-compact-productive-controller +``` + +The registered commands regenerate only fresh temporary output. The direct +checks also work from an exported source bundle: + +```sh +python3 -I -O -B research/bit-compact-productive-controller/verify.py +python3 -I -O -B research/bit-compact-productive-controller/independent_price.py +``` + +Regenerated gzip containers can differ across Python/zlib versions. The local +word's canonical decompressed payload and the expanded event stream are the +mathematical comparisons. Immutable committed input containers keep exact pins. + +## Open next questions + +The structured questions are in [TASK.json](TASK.json). The next structural +target is a paid reduction in the nine rank-seven owned-copy operations or a +different source-compatible controller. Each copy, target loss, changed frame +and normalization must be included. The present primitive/profile does not +reach0.005 or0.05, and another fine retuning of its crossing does not solve that +structural problem. + +## Credit + +ai-nanachi's merged #4326 compact436 word and its boundary/retirement lineage +are reused; the new contribution is its partial productive ABI, current p16 +installation, all-column requalification and fresh ordinary admission. +Credit Cinna Davis's #4440/#4470 query-thinned controllers and joint-helper +lineage; zxv's productive-helper, higher-moment, finite/compiler, native and +delayed-cover work; Jacob Alan Sussman's mixed-target recursion; the retained +PR589, E8, binary, framing, COPY/ownership, geometry, stock, precision and outer +authors. Mark/Matarener's [#4697](https://github.com/CrocSwap/integer-mult-bounds/pull/4697), +head04e4bd0f0b63799f54c6ae1b7837354b79d1f37d, explains the prior admission constants. + +Prepared by ai-nanachi with substantial OpenAI Codex assistance, including +separate author-side workers for construction, generic admission, independent +series and review. These are author-side checks, distinct from external +reproduction or maintainer acceptance. New work is Apache-2.0; inherited source +notices and immutable packages are preserved. diff --git a/research/bit-compact-productive-controller/RECORD.json b/research/bit-compact-productive-controller/RECORD.json new file mode 100644 index 0000000000..7a7c5903d4 --- /dev/null +++ b/research/bit-compact-productive-controller/RECORD.json @@ -0,0 +1,55 @@ +{ + "schema": 1, + "status": "PROPOSED_CONDITIONAL_ORDINARY_BIT_SUPPLIER", + "scientific_base": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "axis": "ordinary_BIT_saving; raw_mixed_saving separately recorded", + "ordinary_exact": "17713901828029/5120000000000000", + "ordinary_admitted": "34597/10000000", + "raw_saving_interval": [ + "0.003475458064076428997514", + "0.003475458064076428997515" + ], + "previous_raw_interval": [ + "0.003464248972023961106948", + "0.003464248972023961106949" + ], + "previous_exact_ordinary": "8590884599/2500000000000", + "previous_admitted": "17/5000", + "relative_gain_over_previous_exact_ordinary": "58365401/8590884599", + "relative_gain_over_previous_admitted": "597/34000", + "source_type": "New mixed-helper ABI and actual compact p16 word, fresh charged strictification; same conditional framework", + "selected_global_kappa_changed": false, + "complex_supplier_changed": false, + "selected_global_kappa_at_base": "60403/20000000", + "author_side_verification": "Exact finite native/caller and price checks; pending external acceptance", + "external_third_party_reproduction": "No independent external report observed; hosted author-submitted replay is recorded separately.", + "maintainer_admission": "Pending; no reviews observed at this observation.", + "hosted_CI": { + "observed_at_utc": "2026-10-22T19:30:54.133903+00:00", + "head_sha": "08fab758c76909aaff4bf163627ecdd60ca41a84", + "checks": [ + { + "name": "replay (research/bit-compact-productive-controller) / replay (research/bit-compact-productive-controller)", + "status": "completed", + "conclusion": "success", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39838963514/job/120035934374" + }, + { + "name": "plan", + "status": "completed", + "conclusion": "success", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39838963514/job/120034618603" + } + ], + "scope": "Hosted package replay, separate from external mathematical acceptance; this observation is tied only to the stated head." + }, + "publication": { + "PR": 4760, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4760", + "created_at_utc": "2026-10-22T19:18:40Z", + "initial_posted_head": "08fab758c76909aaff4bf163627ecdd60ca41a84", + "scientific_commit": "c0945c235432fc83547c2db80896ba8a64b5f49f", + "status_at_observation": "open", + "cadence_rule": "Only this actual creation time counts as a new PR; edits and added commits do not." + } +} diff --git a/research/bit-compact-productive-controller/RESULT.json b/research/bit-compact-productive-controller/RESULT.json new file mode 100644 index 0000000000..0005dc4ec3 --- /dev/null +++ b/research/bit-compact-productive-controller/RESULT.json @@ -0,0 +1,1228 @@ +{ + "expanded": { + "additional_partial_outputmatcher_routes": 144, + "cancellation_free_majorant_bits": 485, + "event_counts": { + "ADD": 33078, + "LOCAL_ADD": 343278, + "LOCAL_COPY_QUERY": 162, + "LOCAL_PAID_CLEAR": 162, + "LOCAL_QUERY": 52182, + "PAID_PORT_ROUTE": 7548, + "PAID_WHOLE_IDLE": 3330, + "THIN_ADD": 1665, + "THIN_COPY": 1665, + "THIN_PAID_CLEAR": 1665, + "THIN_PAID_QUERY": 1665 + }, + "expanded_event_count": 446400, + "expanded_event_sha256": "7600cb4bb35e9a3f9facd68b606aefc34a115abd3bb50479354368d95246dd44", + "nonidentity_mainport_routes": 7548, + "private_episodes": 1827, + "private_peak": 1, + "raw_scalar_columns": 11400, + "raw_scalar_record_bound": 1000000000 + }, + "expanded_negative_controls": { + "duplicate_owner": "REJECT", + "full8_credit": "REJECT", + "omit_clear": "REJECT", + "source_write_in_lease": "REJECT", + "wrong_nested_frame": "REJECT" + }, + "invoice": { + "helper_original_fields": 7848, + "main_original_fields": 3552, + "original_fields": 11400, + "paid": { + "1": 25407, + "14": 444, + "2": 24156, + "21": 444, + "28": 444, + "3": 1404, + "35": 444, + "4": 702, + "42": 444, + "49": 444, + "5": 1836, + "56": 444, + "6": 180, + "63": 222, + "7": 324 + }, + "rank_surplus": 753, + "targets": { + "127": 222, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "4": 72, + "43": 444, + "50": 444, + "57": 444, + "64": 222, + "8": 7776 + }, + "thick_calls": 18, + "thin_queries": 1665 + }, + "local": { + "canonical_payload_sha256": "6f8516694bd0067897e91311fb16a749eea8fdd2eb3761bfa3f8eb2740d5c6a6", + "exact_signed_inverse_both_orders": true, + "forward": { + "COPY_episodes": 9, + "columns": 658, + "direction": "forward", + "helper_ranks": { + "4": 4, + "8": 432 + }, + "paid": { + "1": 1319, + "2": 1342, + "3": 78, + "4": 39, + "5": 102, + "6": 10, + "7": 18 + }, + "unit_ADDs": 19071 + }, + "helper_matchers": { + "462": { + "all_f": "Tensor I_f; C_(8f)=C8 tensor Cf and the two Cf factors cancel.", + "canonical_input_route_matrix": "matcher_inverse", + "canonical_return_route_matrix": "matcher", + "frame": 506, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "physical_reversed_tail_covariance": true, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "rank": 4 + }, + "463": { + "all_f": "Tensor I_f; C_(8f)=C8 tensor Cf and the two Cf factors cancel.", + "canonical_input_route_matrix": "matcher_inverse", + "canonical_return_route_matrix": "matcher", + "frame": 506, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "physical_reversed_tail_covariance": true, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "rank": 4 + }, + "466": { + "all_f": "Tensor I_f; C_(8f)=C8 tensor Cf and the two Cf factors cancel.", + "canonical_input_route_matrix": "matcher_inverse", + "canonical_return_route_matrix": "matcher", + "frame": 508, + "matcher": [ + [ + "1", + "1", + "1", + "1", + "-1", + "-1", + "-1", + "2" + ], + [ + "0", + "-1", + "-1", + "-1", + "-1", + "-1", + "0", + "1" + ], + [ + "-1", + "0", + "0", + "-1", + "-1", + "0", + "-1", + "1" + ], + [ + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "1", + "0", + "0", + "1", + "1", + "-1" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "1", + "0", + "0" + ], + [ + "-1", + "1", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "-1", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "1/4", + "1/4", + "-1/4", + "1/4", + "1/4", + "1/4", + "-1/4", + "-1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "0", + "1/4", + "1/4", + "-1/2" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "1/4", + "-1/2", + "0", + "1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "-1/2", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "1/2", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "1/4", + "1/2", + "0", + "1/4" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "0", + "1/4", + "1/4", + "1/2" + ] + ], + "physical_reversed_tail_covariance": true, + "projector": [ + [ + "1/2", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "-1/4", + "1/2", + "0", + "1/4", + "0", + "1/4", + "-1/4", + "0" + ], + [ + "-1/4", + "0", + "1/2", + "1/4", + "0", + "-1/4", + "1/4", + "0" + ], + [ + "0", + "1/4", + "1/4", + "1/2", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "1/2", + "-1/4", + "-1/4", + "0" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "-1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "-1/4", + "0", + "1/2", + "-1/4" + ], + [ + "-1/4", + "0", + "0", + "-1/4", + "0", + "-1/4", + "-1/4", + "1/2" + ] + ], + "rank": 4 + }, + "468": { + "all_f": "Tensor I_f; C_(8f)=C8 tensor Cf and the two Cf factors cancel.", + "canonical_input_route_matrix": "matcher_inverse", + "canonical_return_route_matrix": "matcher", + "frame": 509, + "matcher": [ + [ + "1", + "1", + "1", + "1", + "-1", + "-1", + "-1", + "-2" + ], + [ + "0", + "1", + "1", + "1", + "1", + "1", + "0", + "1" + ], + [ + "1", + "0", + "0", + "1", + "1", + "0", + "1", + "1" + ], + [ + "0", + "0", + "0", + "-1", + "1", + "0", + "0", + "0" + ], + [ + "-1", + "0", + "-1", + "0", + "0", + "-1", + "-1", + "-1" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "1", + "0", + "0" + ], + [ + "-1", + "1", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "1/4", + "-1/4", + "1/4", + "1/4", + "-1/4", + "1/4", + "-1/4", + "1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "0", + "1/4", + "1/4", + "1/2" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "-1/4", + "-1/2", + "0", + "-1/4" + ], + [ + "0", + "1/4", + "1/4", + "-1/2", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "0", + "1/4", + "1/4", + "1/2", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "-1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "-1/4", + "0", + "1/2", + "-1/4" + ], + [ + "-1/4", + "0", + "0", + "-1/4", + "0", + "-1/4", + "-1/4", + "1/2" + ] + ], + "physical_reversed_tail_covariance": true, + "projector": [ + [ + "1/2", + "1/4", + "1/4", + "0", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "1/4", + "1/2", + "0", + "-1/4", + "0", + "-1/4", + "1/4", + "0" + ], + [ + "1/4", + "0", + "1/2", + "-1/4", + "0", + "1/4", + "-1/4", + "0" + ], + [ + "0", + "-1/4", + "-1/4", + "1/2", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "-1/4", + "0", + "0", + "-1/4", + "1/2", + "1/4", + "1/4", + "0" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "1/4", + "1/2", + "0", + "1/4" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "0", + "1/4", + "1/4", + "1/2" + ] + ], + "rank": 4 + } + }, + "inverse": { + "COPY_episodes": 9, + "columns": 658, + "direction": "inverse", + "helper_ranks": { + "4": 4, + "8": 432 + }, + "paid": { + "1": 1319, + "2": 1342, + "3": 78, + "4": 39, + "5": 102, + "6": 10, + "7": 18 + }, + "unit_ADDs": 19071 + }, + "old_scalar_threshold_reused": false, + "scalar_majorant_bits": 30 + }, + "main": { + "calls": 18, + "main_columns": 3552, + "main_source_abi_unchanged": true, + "native_backend": { + "binary_charts": 111, + "complex_contacts_and_inverses": 896, + "owned_stream_restored_zero": true, + "thin_paid_rank_per_port": 1, + "thin_productive_credit": 0 + }, + "pairs": 16, + "prefix": 7, + "thin_queries": 1665 + }, + "negative_controls": { + "changed_SOURCE_version": "REJECT", + "changed_actual_ADD": "REJECT", + "missing_paid_QUERY": "REJECT", + "unpaid_rank8_helper_credit": "REJECT", + "unreturned_owned_copy": "REJECT", + "warm_partial_helper": "REJECT" + }, + "new_complex_or_global_kappa": null, + "ordinary_BIT": { + "WORD_changed": true, + "admitted": "34597/10000000", + "after_cover": "8887360519/2560000000000", + "comparators": { + "PR4697_fixed_C0_prime_saturated_sup": "8845274375/2568746817031", + "current_admitted": "17/5000", + "current_exact_ordinary": "8590884599/2500000000000" + }, + "margins": { + "adapter": "1298171971/5120000000000000", + "ordinary_relaxation": "237828029/5120000000000000", + "prime_allowance": "17179869184/9765881", + "stock": "5084570898171971/5120000000000000" + }, + "new_whole_kappa": null, + "ordinary_exact": "17713901828029/5120000000000000", + "params": { + "admitted": "34597/10000000", + "alpha_gap": "1/4294967296", + "atom": "173/50000", + "cover_gap": "9765881/2560000000000", + "old_backend": "384599/10000000000", + "prime_coefficient": 67108864, + "tested": "69509/20000000", + "uniform": "43443/12500000" + }, + "relative_gains": { + "PR4697_fixed_C0_prime_saturated_sup": "418189878821507/88452743750000000", + "current_admitted": "597/34000", + "current_exact_ordinary": "58365401/8590884599" + }, + "scope": "Conditional ordinary BIT supplier only; main selected/complex result unchanged.", + "tail": { + "alpha": { + "lower": "0.999999991905059684301510340131", + "upper": "0.999999991905059684301510340132" + }, + "compiler_H0": 377227157504, + "cutoff_base": 17, + "delta": { + "lower": "0.948389236578657043633140116103", + "upper": "0.948389236578657043633140116104" + }, + "gamma": { + "lower": "0.958113118679772899937220732700", + "upper": "0.958113118679772899937220732701" + }, + "normalized_surplus_lower": "1069547519/4503600701112320", + "tail_exponent": "1/5", + "target_floor_base": 18, + "tensor_power": 1024, + "tested_saving": "69509/20000000", + "uniform_H1": 262206447682297857, + "uniform_N": "2^262206447682297857", + "uniform_saving": "43443/12500000", + "winning_word_materialized": false + } + }, + "schema": "compact-partial-productive-BIT/1", + "scope": "Finite all-column native schematic and conditional ordinary BIT supplier. Paid tensor completion/splitting, delayed-cover/fallback and stock are retained. New fixed constants must be generated from this word; no massive uniform word or global multiplication theorem is materialized.", + "separate_stream_interpreter": { + "SOURCE_versions": "all mutable/capture epochs checked", + "columns": 11400, + "events": 446400, + "query_count": 57339, + "scope": "decoded RAW plus exact current FRAME/owner/private; all-function map additionally uses the commonFRAME and physical main polynomial lemmas", + "status": "PASS_EMITTED_STREAM_SEPARATE_INTERPRETER" + }, + "source_inputs_authenticated": 26, + "status": "PASS_CONDITIONAL_ORDINARY_BIT_0034597" +} diff --git a/research/bit-compact-productive-controller/SOURCES.json b/research/bit-compact-productive-controller/SOURCES.json new file mode 100644 index 0000000000..8f71420ff2 --- /dev/null +++ b/research/bit-compact-productive-controller/SOURCES.json @@ -0,0 +1,174 @@ +{ + "schema_version": 1, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "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/bit-compact-carrier-retirement/provider/inputs/GEOMETRY.json.gz", + "usage": "input", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "path": "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "usage": "input", + "git_blob": "776ddd13d67b2259e90d39de5b42e4df4b1447f1", + "sha256": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "usage": "input", + "git_blob": "8b40135a84e7f0f0cd44bed69655801310b916a7", + "sha256": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85" + }, + { + "path": "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/kappa-rebuild/architecture/mixed_target_probe.py", + "usage": "input", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "path": "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "usage": "input", + "git_blob": "fbe6da7241357d89cf5c55b2e7ce2d0d046be32a", + "sha256": "edb273f59a27356ad89f38791590c3c806b228c3510eb508e01e89f2caba95ef" + }, + { + "path": "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "usage": "input", + "git_blob": "e8c5e4f077fea0bef355e6c3013c7f252d3606cf", + "sha256": "9ece46fdfda6182e757e9a3b1f513fb3d029d730f3bafdcd6ed59180a14175b0" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "input", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "usage": "input", + "git_blob": "6a139eedbc1015c13df6f2a4333e1a89b5edd18d", + "sha256": "2f69a19f417c0e0d141c180f9b2fae3d358391b9a230f5848ee07c45450e70bf" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "input", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/complex_controller_factor.py", + "usage": "input", + "git_blob": "cb0cff7c8be5f38f2ee52201d9d0907f9dfd7947", + "sha256": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497" + }, + { + "path": "research/kappa-rebuild/bit/mixed_productive_bit.py", + "usage": "input", + "git_blob": "9c7a8bd5d3ae4c19952648c815031858d6627b96", + "sha256": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "usage": "input", + "git_blob": "a9a932b9268da28af9ba4bccdab205c5bcd50ad3", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + { + "path": "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "usage": "input", + "git_blob": "f97a23d7d21bd7f79c9d0cb14d8c6b44fddd3f23", + "sha256": "c4aa88c4943ef041e9542c519b7600ecf26ed6caff92558fdb07ac88ace64c17" + }, + { + "path": "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "usage": "input", + "git_blob": "c6edcbdc43bf36bb11201235027d0ec170d07fc8", + "sha256": "943d5fad2fc529f470df05a35446e07ecaef7344abfce450d2c2eb2c9b3798f6" + }, + { + "path": "research/pr4359-p7-padding/TENSOR.md", + "usage": "input", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/native_inventory.py", + "usage": "input", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "path": "research/query-thinned-controllers/BIT-CONTROLLER.json", + "usage": "input", + "git_blob": "89c400d5970024b3debe870c36ce43889beed001", + "sha256": "39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d" + }, + { + "path": "research/query-thinned-controllers/PROOF.md", + "usage": "input", + "git_blob": "9068f429896112082664455ab00bab083c99d1d8", + "sha256": "5ade59641f2ed70d045d6f60e89db7d979b1d1e9967f3acbe5c56eac81312841" + }, + { + "path": "research/query-thinned-controllers/SOURCES.json", + "usage": "input", + "git_blob": "0f061c87ff87c43ff1ea0fc418582e9ccea3bc1d", + "sha256": "74b73563d9f78a4562d376b6f33528d652e41097f65747667f112a3e1fa81d29" + }, + { + "path": "research/query-thinned-controllers/controller.py", + "usage": "input", + "git_blob": "d4557e08cfb9fe57cc1ae4024705a72dc95f3583", + "sha256": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2" + }, + { + "path": "research/query-thinned-controllers/verify.py", + "usage": "input", + "git_blob": "f1114036fff66f57014e5c1256141fb78ff4c4a9", + "sha256": "07dea601d6bbaa4d90e576f20c8607c37fb01e8778c798d919fa9df435049950" + } + ] +} diff --git a/research/bit-compact-productive-controller/TASK.json b/research/bit-compact-productive-controller/TASK.json new file mode 100644 index 0000000000..5ef443187f --- /dev/null +++ b/research/bit-compact-productive-controller/TASK.json @@ -0,0 +1,106 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a source-bound compact partial-helper ordinary BIT supplier and independently verify the changed physical and recursive bill.", + "scope_change_reason": "Explicit donor assignment targets BIT improvements. The older independent-moment card becomes an actual interface/controller change, with separate native and price audits.", + "bottleneck_link": "Four genuine rank4 helper jobs replace paid rank8 completion; compact436 replaces the old439-helper primitive. The changed complete concave moment improves although rank-one surplus stays753.", + "budget_minutes": 180, + "stop_rule": "Require all original RAW columns, caller/source/frame/private invariants, charged completion/splitting/cover/stock and exact ordinary gaps. Publish only after a fresh leading-record comparison.", + "outcome": "completed", + "evidence": "PROOF.md, RESULT.json, RECORD.json; verify.py and independent_price.py plus their native/stream controls.", + "author": "ai-nanachi", + "ai_assistance": "Substantial OpenAI Codex assistance with three reused workers and main-side independent native/price implementation. Author-side AI reviews are not external human acceptance.", + "open_questions": [ + { + "question": "Can rank7 owned-copy work be removed with a legal changed producer/consumer?", + "why_it_matters": "Three saved rank7 calls per full invocation would materially change the first-moment surplus; current concavity-only gain does not reach the donor0.005 target.", + "first_step": "Emit an arbitrary-input, source-version-bound small replacement for one actual copy window, charging every dirty reset, retained target and route.", + "blocked_by": "No cheaper complete copy/consumer has been proved." + }, + { + "question": "Can an independent reviewer bind this changed partial-helper ABI through the full selected physical compiler?", + "why_it_matters": "The finite raw identities and conditional compiler application have different verification scopes.", + "first_step": "Replay one rank4 helper at two column multiplicities through the complete-GL row protocol and inspect all owned-bank and external-weight conditions.", + "blocked_by": "Inherited universal native/tape and source-implementation premises; no massive template materialization." + } + ] +} diff --git a/research/bit-compact-productive-controller/VALIDATION.md b/research/bit-compact-productive-controller/VALIDATION.md new file mode 100644 index 0000000000..19c6735bfa --- /dev/null +++ b/research/bit-compact-productive-controller/VALIDATION.md @@ -0,0 +1,44 @@ +# Author-side validation + +Scientific base: b58ad9ef4d4e861b0eaa5dba41742bdc072dca51. +Windows, bundled CPython3.12.14; standard library only. + +Completed on the final scientific implementation: + +- Registered metadata and live-source authentication: PASS. +- Registered `verify.py` and `independent_price.py`: PASS. +- Direct isolated optimized `verify.py`: PASS, all11,400 originals and the + physical/frame/owner/capture conditions; six local and five emitted-stream + corruptions rejected. +- Direct isolated optimized independent price: PASS, both raw-root brackets, + full completion/splitting, compiler integers, cover/stock/ordinary gaps; + four arithmetic corruptions rejected. +- The portable local/global producer and emitted-stream auditor also passed + separate normal and optimized Python3.12 runs before public integration. +- Separate author-side reviews checked the actual partial-helper ABI, + canonical matcher direction, generic admission and finite-constant scope. + Three wording corrections were applied: signed versus Boolean coverage, + removed helper-credit accounting and admitted versus exact improvement rates. + +The emitted program, helper projectors and finite certificates are regenerated +in temporary directories. Comparisons use canonical decompressed content; +gzip OS header differences across Python versions are excluded. Immutable +input archive hashes remain checked. + +Scientific commit `c0945c235432fc83547c2db80896ba8a64b5f49f` passed the +43-file committed-byte/source-history preflight and committed export integrity +check. A fresh43-file Git-free export then passed both direct scripts under +CPython3.12.14 `-I -O -B`, with an empty PATH (2026-10-22T19:13:24Z). +No network-denial policy is claimed for that replay. Later publication records +are metadata-only and retain the scientific implementation. + +Before submission the canonical main fetch remained +`b58ad9ef4d4e861b0eaa5dba41742bdc072dca51`. The overlap refresh covered506 open +PRs,3858 closed PRs and3667 Discussion records with complete reported remote +pagination; sparse local note coverage was incomplete. Literal-term results +are leads, not proof of novelty. The current BIT source, PR4697 and the relevant +recent typed-interface/outer proposals were compared at their pinned heads. + +No external human +review, hosted-CI success, selected full cold replay, materialized uniform +template or new global multiplication κ is claimed here. diff --git a/research/bit-compact-productive-controller/VERIFY.json b/research/bit-compact-productive-controller/VERIFY.json new file mode 100644 index 0000000000..d2462f5829 --- /dev/null +++ b/research/bit-compact-productive-controller/VERIFY.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-compact-carrier-retirement/provider/inputs/GEOMETRY.json.gz", + "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "research/higher-moment-strictification/README.md", + "research/higher-moment-strictification/verify.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "research/kappa-rebuild/architecture/mixed_target_probe.py", + "research/kappa-rebuild/bit/BIT-ALLSIZE-PARAMETERS.json", + "research/kappa-rebuild/bit/BIT-P3-NATIVE-BINDING.json", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "research/kappa-rebuild/bit/MIXED-PRODUCTIVE-BIT.json", + "research/kappa-rebuild/bit/bit_native_binding.py", + "research/kappa-rebuild/bit/complex_controller_factor.py", + "research/kappa-rebuild/bit/mixed_productive_bit.py", + "research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "research/kappa-rebuild/complex/FULL-IDENTITY.md", + "research/kappa-rebuild/complex/full-identity-certificates/RESULT.json", + "research/pr4359-p7-padding/TENSOR.md", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/pr4359-p7-padding/native_inventory.py", + "research/query-thinned-controllers/BIT-CONTROLLER.json", + "research/query-thinned-controllers/PROOF.md", + "research/query-thinned-controllers/SOURCES.json", + "research/query-thinned-controllers/controller.py", + "research/query-thinned-controllers/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "Source authentication; all658 local and11400 global RAW; physical main polynomials/ports and partial projectors; SOURCE frames/versions/private; complete paid tensor/ordinary certificate;11 native/stream mutants." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/independent_price.py" + ], + "timeout_seconds": 120, + "checks": "Separate literal-census reconstruction, positive-series exact intervals/raw root brackets, all tails/compiler/cover/atom/stock, four rejecting arithmetic controls." + } + ] +} diff --git a/research/bit-compact-productive-controller/audit_stream.py b/research/bit-compact-productive-controller/audit_stream.py new file mode 100644 index 0000000000..ad4f140b3e --- /dev/null +++ b/research/bit-compact-productive-controller/audit_stream.py @@ -0,0 +1,130 @@ +"""Read the emitted candidate stream without importing its producer. + +This checks the decoded RAW map and finite FRAME/owner/lease conditions. +The all-function conclusion additionally uses the common-FRAME lemma and +the independently recorded physical main polynomial identity, not RAW rank. +""" +from pathlib import Path +from collections import Counter +from hashlib import sha256 +import argparse,gzip,json + + +def need(v,m): + if not v:raise ValueError(m) + + +def audit(repo_root,local_dir,global_dir,mutant=None): + repo_root,local_dir,global_dir=map(Path,(repo_root,local_dir,global_dir)) + w=json.loads(gzip.decompress((local_dir/'WORD.json.gz').read_bytes())) + frames=json.loads((repo_root/'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json').read_bytes())['frames'] + calls=json.loads((global_dir/'CALLS.json').read_bytes()) + result=json.loads((global_dir/'RESULT.json').read_bytes()) + if mutant=='duplicate_owner':calls[1]['helper_owner_begin']=calls[0]['helper_owner_begin'] + if mutant=='full8_credit': + result['targets']['8']+=72;result['targets']['4']-=72 + need(len(calls)==18,'18 independent native invocations') + owned=[i for call in calls for i in range(call['helper_owner_begin'],call['helper_owner_begin']+436)] + need(len(owned)==len(set(owned))==7848 and set(owned)==set(range(3552,11400)),'injective fresh helper ownership') + n=11400;values=[1<=8) for b in range(15)] for a in range(15)] + need(mm(rho,rho)==eye(15) and mm(mm(rho,local8),rho)==expected,'same finite15D wholefiber route, no free dense currentview') + ports.append(dict(port=i,root=[str(x) for x in q],chart_sha256=digest([[str(x) for x in row] for row in rho]))) + jobs={'independent_roles':[dict(role=i,initial_frame=word['start'][i],job_frame=word['final'][i],rank=frames[str(word['final'][i])]['dim']) for i in range(222,658)]} + need(all(row['initial_frame']==0 for row in jobs['independent_roles']),'all helpers cold ordinary originals') + need(len(jobs['independent_roles'])==436,'alloriginal helper roles') + matchers={} + for f in sorted({row['job_frame'] for row in jobs['independent_roles']}): + H=project(f);rank=frames[str(f)]['dim'] + need(mm(H,H)==H and sum(H[i][i] for i in range(8))==rank,'exact helperoutput idempotent rank') + if rank==8: + need(H==I,'fullhelpers');continue + B=[[Q(x) for x in row] for row in frames[str(f)]['B']];A=[[Q(x) for x in row] for row in frames[str(f)]['A']] + need(rank==4 and len(B)==len(A)==4,'actual image/kernel rank4 basis') + S=list(map(list,zip(*(B+A))));SI=matrix_inverse(S) + Q4=[[Q(i==j and i<4) for j in range(8)] for i in range(8)] + need(mm(mm(S,Q4),SI)==H,'explicit image+kernel output job matcher') + matchers[str(f)]=dict(rank=rank,projector=[[str(x) for x in row] for row in H],S=[[str(x) for x in row] for row in S],S_inverse=[[str(x) for x in row] for row in SI]) + need(len(matchers)==3,'three distinct actual rank4 helperjobs') + return dict(ports=ports,matchers=matchers,all_f='Every head projector/matcher embeds in one final ambient and tensorsI_f; use retained C_Nf for the reversed tail, not a runtime relabeling.', + helper_cover='Helpers are independent fields at the localinvocation cover rowh, not per-port-routed main fields. No rho_q is silently applied to a helperjob.', + matcher_direction='Stored S satisfies S Q4 S^-1=H4. To use childH4 as canonicalparentQ4, route input wholefiber g->g S^-1, finish wholeunit, undo route. For arbitrary parentP use B_P B_H4^-1.', + partial_job_routes='72 output roles need wholefiber matcher/inverse when used by the finite compiler:144 positive fixed routes, no extra input/output credit.') + + +def build(repo_root, local_dir, out): + repo_root,local_dir,out=map(Path,(repo_root,local_dir,out)) + out.mkdir(parents=True,exist_ok=True) + need(not any(out.iterdir()),'fresh GLOBAL output directory required') + SOURCE,LOCAL,HERE=repo_root,local_dir,out + started=time.process_time();cp=SOURCE/'research/query-thinned-controllers/BIT-CONTROLLER.json' + need(sha256(cp.read_bytes()).hexdigest()=='39ac84fb848b908f7ba051fae4556d507900c421dc5d23501a9c0cb1d61fd08d','exact current p16controller pin') + controller=json.loads(cp.read_bytes());thick=controller['invoice']['thick_stages'] + need(len(thick)==18 and len(set(thick))==18,'actual thickstage roster') + active_embedding=[dict(stage=s,kind='central K_q=I8-P_q' if j==0 else 'fresh orthogonal rank7 B_s', + active_block=j,axes=list(range(8)) if j==0 else list(range(8+7*(j-1),8+7*j))) for j,s in enumerate(thick)] + need(max(a for row in active_embedding for a in row['axes'])==126,'actual127-axis injective thin-stage deletion') + wpath=LOCAL/'WORD.json.gz';need(sha256(gzip.decompress(wpath.read_bytes())).hexdigest()=='6f8516694bd0067897e91311fb16a749eea8fdd2eb3761bfa3f8eb2740d5c6a6','actual partialLOCAL canonical content pin') + word=json.loads(gzip.decompress(wpath.read_bytes()));fpath=SOURCE/'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json' + need(sha256(fpath.read_bytes()).hexdigest()=='d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010','exact current frame source') + refpath=SOURCE/'research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz' + need(sha256(refpath.read_bytes()).hexdigest()=='e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f','exact current reference WORD') + frames=json.loads(fpath.read_bytes())['frames'];reference=json.loads(gzip.decompress(refpath.read_bytes())) + formal=formal_main(controller);binding=port_and_helper_proofs(word,frames,reference) + values=[1<>1).bit_count()]+=V + expected_paid={1: 25407, 2: 24156, 3: 1404, 4: 702, 5: 1836, 6: 180, 7: 324, 14: 444, 21: 444, 28: 444, 35: 444, 42: 444, 49: 444, 56: 444, 63: 222} + expected_targets={4: 72, 8: 7776, 15: 444, 22: 444, 29: 444, 36: 444, 43: 444, 50: 444, 57: 444, 64: 222, 127: 222} + need(dict(sorted(profile.items()))==expected_paid,'actualexpandedpaid ledger') + need(dict(sorted(targets.items()))==expected_targets,'every actual independent helper/main outputcredit') + need(max(profile)<127 and sum(targets.values())==N,'proper requests, no private orghost Wcredit') + result=dict(status='PASS_CURRENT_PARTIAL436_THIN_CONTROLLER_ALL11400_RAW_AND_INDEPENDENT_JOBS',at_utc=datetime.now(timezone.utc).isoformat(), + raw_scalar_columns=N,main_original_fields=3552,helper_original_fields=7848, + raw_column_scope='Inline all11400 decodedF2 columns plus exact per-LOCAL frame/function invariant, rational mainportcharts and every physical main polynomial coefficient. Not only coefficient-row SOURCE projection.', + paid=dict(sorted(profile.items())),targets=dict(sorted(targets.items())),query_count=sum(profile.values()), + rank_surplus=sum(r*n for r,n in targets.items())-sum(r*n for r,n in profile.items()), + helper_full8=7776,helper_partial4=72,private_original_credit=0,private_peak=1,private_episodes=len(private_episodes), + nonidentity_mainport_routes=counts['PAID_PORT_ROUTE'],additional_partial_outputmatcher_routes=144, + event_counts=dict(counts),expanded_event_count=event_index,expanded_event_sha256=stream_hash.hexdigest(), + expanded_gzip_sha256=sha256((HERE/'EXPANDED-PROGRAM.jsonl.gz').read_bytes()).hexdigest(), + cancellation_free_integer_majorant=peak,cancellation_free_majorant_bits=peak.bit_length(), + raw_scalar_record_bound=10**9,source_type_lift='Single delayed wholeGL ambient, common externalweight independent of freshroles/cover, allfixed projectors tensorI_f and retained C_Nf tail. No free dense reframe or inherited changedROWconstants.', + fee_scope='All localCOPY/clear,thinCOPY/query/clear,bridge/swaps,wholeidle retained;144 new wholefiber matcher routes plus newrow/stock/normalizer/precision constants must be charged in root strictification.', + complete_ordinary_or_whole_claim=False,CPU_seconds=time.process_time()-started, + sourcepins=[dict(path=str(p),sha256=sha256(p.read_bytes()).hexdigest()) for p in [cp,wpath,fpath,refpath]]) + need(event_index+2*sum(profile.values())+2*N+144<10**9,'conservative finite rawrecord/route accounting fits declared bound') + for name,data in [('RESULT.json',result),('MAIN-PHYSICAL-COEFFICIENTS.json',formal),('OWNERS.json',owners),('CALLS.json',calls),('PRIVATE-EPISODES.json',private_episodes),('RATIONAL-BINDING.json',binding),('ACTIVE-AXES.json',active_embedding)]: + (HERE/name).write_text(json.dumps(data,indent=2)+'\n',encoding='utf-8') + return result + + +def main(): + p=argparse.ArgumentParser() + p.add_argument('--repo-root',type=Path,required=True) + p.add_argument('--local-dir',type=Path,required=True) + p.add_argument('--out',type=Path,required=True) + args=p.parse_args();result=build(args.repo_root,args.local_dir,args.out) + print(json.dumps({k:result[k] for k in ['status','raw_scalar_columns','query_count','rank_surplus','helper_full8','helper_partial4','expanded_event_count','cancellation_free_majorant_bits','CPU_seconds']})) + + +if __name__=='__main__':main() diff --git a/research/bit-compact-productive-controller/independent_native.py b/research/bit-compact-productive-controller/independent_native.py new file mode 100644 index 0000000000..bb41064dd1 --- /dev/null +++ b/research/bit-compact-productive-controller/independent_native.py @@ -0,0 +1,133 @@ +"""Separate Boolean/raw interpreter and rational helper-job matching. + +The state is all658 original symbols, never just the111 SOURCE symbols. +Frames specify actual ADDRESS pullbacks; equality of VALUE rows alone is +insufficient. The rank7 owned-copy backend is inherited, charged and leased. +""" +from fractions import Fraction as F +from collections import Counter + +N=658;V=111 +LOCAL={1:1319,2:1342,3:78,4:39,5:102,6:10,7:18} + +def need(c,m): + if not c:raise ValueError(m) + +def rank(a): + a=[[F(v)for v in row]for row in a] + if not a:return 0 + r=0 + for j in range(len(a[0])): + k=next((i for i in range(r,len(a))if a[i][j]),None) + if k is None:continue + a[r],a[k]=a[k],a[r];x=a[r][j];a[r]=[v/x for v in a[r]] + for i in range(r+1,len(a)): + if a[i][j]: + x=a[i][j];a[i]=[v-x*w for v,w in zip(a[i],a[r])] + r+=1 + if r==len(a):break + return r + +def inverse(a): + n=len(a);a=[[F(x)for x in row]+[F(i==j)for j in range(n)]for i,row in enumerate(a)] + for j in range(n): + k=next(i for i in range(j,n)if a[i][j]);a[j],a[k]=a[k],a[j] + q=a[j][j];a[j]=[v/q for v in a[j]] + for i in range(n): + if i!=j and a[i][j]: + q=a[i][j];a[i]=[v-q*w for v,w in zip(a[i],a[j])] + return [row[n:]for row in a] + +def mm(a,b):return [[sum(x*y for x,y in zip(row,col))for col in zip(*b)]for row in a] + +def project(frame): + b=[[F(x)for x in row]for row in frame['B']] + if not b:return [[F(0)]*8 for _ in range(8)] + bt=list(map(list,zip(*b))) + return mm(mm(bt,inverse(mm(b,bt))),b) + +def verify(word,frames,reference,reverse=False): + need(word['active_ordinary_roles']==word['namespace']==N,'Original namespace658') + need(len(word['start'])==len(word['final'])==N,'All original boundaries') + need(word['start'][:222]==reference['start'][:222]and word['final'][:222]==reference['final'][:222], + 'Exact main SOURCE/Y interface, including coordinate flags') + need(all(f==0 for f in word['start'][222:]),'All436 helper inputs start arbitrary and cold') + expected_helpers=Counter(frames[str(f)]['dim']for f in word['final'][222:]) + need(expected_helpers=={4:4,8:432},'Actual independent partial-target ranks') + used={f for f in word['start']+word['final']} + for e in word['records']: + if e[0]==0:used.update(e[2:4]) + else:used.add(e[4]) + for f in used: + frame=frames[str(f)];b,a=frame['B'],frame['A'];d=frame['dim'] + need(len(b)==d and len(a)==8-d and rank(b+a)==8,'Complete actual frame bases') + need(all(sum(x*y for x,y in zip(u,v))==0 for u in b for v in a),'Frame orthogonal complement') + state=list(word['final']if reverse else word['start'])+[None] + rows=[1<=8192 and H0*h*d>=d*(5+8*h)*1024+1+8*1024*(1-z0),'Integer compiler induction') + need(H1*(z-z0)>H0*(1-z0),'Finite uniform dimension') + c1=uniform-gap;a=(1-atom)*c1+atom*old + need(tested>uniform>c1>0 and atom>a>b>0 and atom<1-a,'Ordinary adapter/mixed/stock exponents') + need(F(p['prime_coefficient'])>256/gap,'Full delayed-cover fallback prime allowance') + return {'alpha':alpha,'gamma':gamma,'delta':delta,'H0':H0,'H1':H1,'ordinary':a,'admitted':b} + +def audit(): + target,paid,local,helper,old_invoice=census() + result=json.loads((HERE/'RESULT.json').read_bytes()) + need({str(k):v for k,v in target.items()}==result['invoice']['targets']and + {str(k):v for k,v in paid.items()}==result['invoice']['paid'],'Independent complete census') + params=result['ordinary_BIT']['params'];calc=check(target,paid,params) + need(calc['ordinary']==F(result['ordinary_BIT']['ordinary_exact'])and calc['admitted']==F('0.0034597'), + 'Exact admitted ordinary coefficient') + need(calc['H0']==result['ordinary_BIT']['tail']['compiler_H0']and + calc['H1']==result['ordinary_BIT']['tail']['uniform_H1'],'Independent compiler integers') + for name in ('alpha','gamma','delta'): + display=result['ordinary_BIT']['tail'][name] + need(F(display['lower'])<=calc[name][0]<=calc[name][1]<=F(display['upper']), + 'Independent interval lies within primary displayed enclosure') + controls={} + for name,change in [('old_atom',{'atom':'0.0034'}),('closed_cover_gap',{'cover_gap':str(F(1,2**18))}), + ('overclaimed_admission',{'admitted':'0.00346'}),('unfunded_alpha_gap',{'alpha_gap':'1/10000000'})]: + try:check(target,paid,dict(params,**change)) + except ValueError:controls[name]='REJECT' + else:raise ValueError('Unrejected arithmetic mutation '+name) + # Direct raw-root sign brackets, not more digits of an unchanged invoice. + roots={} + oldT={int(k):v for k,v in old_invoice['targets'].items()};oldP={int(k):v for k,v in old_invoice['paid'].items()} + for name,T,P,lo,hi in [('old',oldT,oldP,'0.003464248972023961106948','0.003464248972023961106949'), + ('new',target,paid,'0.003475458064076428997514','0.003475458064076428997515')]: + a,b=F(lo),F(hi) + ta,pa=X.moment(T,1-a),X.moment(P,1-a) + tb,pb=X.moment(T,1-b),X.moment(P,1-b) + need(ta[0]>pa[1]and tb[1]=222 and f!=1] + need(found==[(462,506),(463,506),(466,508),(468,509)],'four genuine rank4 partialendpoints') + completion=[] + for role,f in found: + P=project(frames[str(f)]);I=[[Q(i==j) for j in range(8)] for i in range(8)] + C=[[I[i][j]-P[i][j] for j in range(8)] for i in range(8)] + need(mm(P,P)==P and mm(C,C)==C and sum(C[i][i] for i in range(8))==4,'actual rational rank4 completion projector') + completion.append(dict(role=role,from_frame=f,to_frame=1,rank=4,projector=[[str(x) for x in row] for row in C])) + if not partial: + word['records'].append([0,role,f,1,4,0]);word['final'][role]=1 + if partial: + word['format']='compact436-productive-partial/1' + word['productive_interface']=dict(SOURCE_ports=111,TARGET_ports=111,independent_helpers=436,helper_job_ranks={'4':4,'8':432},private_index=658,old_word_sha256=sha256(raw).hexdigest(),paid_completion_count=0) + else: + word['format']='compact436-productive-full8/1' + word['productive_interface']=dict(SOURCE_ports=111,TARGET_ports=111,independent_helpers=436,helper_job_rank=8,private_index=658,old_word_sha256=sha256(raw).hexdigest(),paid_completion_count=4) + expected_profile=dict(EXPECTED) + if partial:expected_profile[4]-=4 + forward,fw=replay(word,frames,expected_profile=expected_profile) + reverse,rv=replay(word,frames,True,expected_profile=expected_profile) + # Signed full inverse uses actual output expressions, not just modulo2. + back,_=replay(word,frames,True,forward,expected_profile) + forth,_=replay(word,frames,False,reverse,expected_profile) + identity=[{i:1} for i in range(N)]+[{}] + need(back==forth==identity,'both exact signed inverse orders onall658 independent RAW') + job_frames=sorted(set(word['final'][222:])) + helper_jobs=dict(projectors={str(f):[[str(x) for x in row] for row in project(frames[str(f)])] for f in job_frames}, + independent_roles=[dict(role=i,initial_frame=0,job_frame=word['final'][i],rank=frames[str(word['final'][i])]['dim']) for i in range(222,N)], + physical_law='Forward D_final*D_initial^-1 on own RAW; reverse uses inverse but idempotent-job involution equals itself. All helper starts0, independent own signedrow, no SOURCE/TARGET contamination.', + cover_lift='Embed exact8x8 P in local first8 ambient axes and tensor I_f; reverse tail uses retained C_Nf convention. No free coordinate adapter.') + (out/'HELPER-ENDPOINTS.json').write_text(json.dumps(helper_jobs,indent=2)+'\n',encoding='utf-8') + (out/'COMPLETIONS.json').write_text(json.dumps(completion,indent=2)+'\n',encoding='utf-8') + packed=json.dumps(word,sort_keys=True,separators=(',',':')).encode() + (out/'WORD.json.gz').write_bytes(gzip.compress(packed,mtime=0)) + (out/'SIGNED-ENDPOINTS.json').write_text(json.dumps(dict(forward=forward,reverse=reverse),indent=2)+'\n',encoding='utf-8') + result=dict(status='PASS_PARTIAL_PRODUCTIVE_LOCAL_ALL658_RAW_NATIVE_AND_SIGNED' if partial else 'PASS_FULL8_PRODUCTIVE_LOCAL_ALL658_RAW_NATIVE_AND_SIGNED',at_utc=datetime.now(timezone.utc).isoformat(), + word_sha256=sha256((out/'WORD.json.gz').read_bytes()).hexdigest(),content_sha256=sha256(packed).hexdigest(), + ordinary_columns=N,independent_helper_columns=R,all_helper_physical_jobs='432 D_I8 and4 actual D_P4, arbitraryindependent initialdata' if partial else 'D_I8, arbitraryinitialdata, no free promotions', + SOURCE_Y_interface_identical_to_current589=True,ordered_SOURCE_lines_identical=True, + forward=fw,reverse=rv,signed_inverse_both_orders=True, + completion_count=0 if partial else 4,complete_LOCAL_rankmass=5089 if partial else 5105,published_partial_LOCAL_rankmass=5089, + productive_helper_ranks={'4':4,'8':432} if partial else {'8':436}, + attribution='Reuses our published compact436/GL464 and credited public boundary/delayed retirement lineage; new mixed productive-helper ABI/current-controller requalification only.', + current_global_not_yet_executed=True, + sourcepins=[dict(path=str(p),sha256=sha256(p.read_bytes()).hexdigest()) for p in [old_word,old_geom,source/'WORD.json.gz',frame_path]],CPU_seconds=time.process_time()-start) + (out/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n',encoding='utf-8') + return result + + +def main(): + p=argparse.ArgumentParser() + p.add_argument('--out',type=Path,required=True) + p.add_argument('--completed',action='store_true',help='Paid full-rank fallback; not the submitted partial ABI') + args=p.parse_args() + result=build(ROOT,args.out,not args.completed) + print(json.dumps({k:result[k]for k in ('status','content_sha256','ordinary_columns','productive_helper_ranks')})) + +if __name__=='__main__':main() diff --git a/research/bit-compact-productive-controller/price.py b/research/bit-compact-productive-controller/price.py new file mode 100644 index 0000000000..07ac039f35 --- /dev/null +++ b/research/bit-compact-productive-controller/price.py @@ -0,0 +1,87 @@ +"""Fully paid p16 invoice and ordinary BIT conversion; no global kappa claim. + +Uses credited source-bound tail engines of Cinna Davis and zxv. The changed +helper ABI retains arbitrary independent rank4 endpoints, rather than paying +to complete them to rank8. Jacob Alan Sussman's mixed-target recursion and +Mark/Matarener's PR4697 parameter derivation are explicit predecessors. +""" +from pathlib import Path +from fractions import Fraction as F +from collections import Counter +import importlib.util,json,sys + +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +THIN=ROOT/'research/query-thinned-controllers' +LOCAL={1:1319,2:1342,3:78,4:39,5:102,6:10,7:18} +OLD_LOCAL={1:1323,2:1342,3:79,4:44,5:102,6:11,7:19} +HELPERS={4:4,8:432} +PARAMS={'tested':F('.00347545'),'uniform':F('.00347544'), + 'cover_gap':F(1,2**18)+F(1,10**10),'atom':F('.00346'), + 'admitted':F('.0034597'),'old_backend':F('.0000384599'), + 'alpha_gap':F(1,2**32),'prime_coefficient':2**26} + +def need(c,m): + if not c:raise ValueError(m) + +def load(p,n): + s=importlib.util.spec_from_file_location(n,p);m=importlib.util.module_from_spec(s) + sys.modules[n]=m;s.loader.exec_module(m);return m + +def source_engines(): + sys.path.insert(0,str(THIN)) + v=load(THIN/'verify.py','compact_productive_credited_tail') + e=load(ROOT/'research/higher-moment-strictification/verify.py','compact_productive_exact_intervals') + return v,e + +def invoice(local,helpers): + need(local==LOCAL and helpers==HELPERS,'Actual local paid/target profile required') + row=json.loads((THIN/'BIT-CONTROLLER.json').read_bytes()) + old=row['invoice'];calls=old['thick_calls'] + need(calls==18 and old['thin_queries']==1665,'Literal p16 full/query inventory') + targets=Counter({int(k):v for k,v in old['targets'].items()}) + paid=Counter({int(k):v for k,v in old['paid'].items()}) + targets[8]-=calls*439 + targets.update({k:calls*v for k,v in helpers.items()}) + for k,n in OLD_LOCAL.items():paid[k]-=calls*n + paid.update({k:calls*v for k,v in local.items()}) + need(all(v>=0 for v in targets.values())and all(v>=0 for v in paid.values()),'No negative jobs') + targets={k:v for k,v in sorted(targets.items())if v} + paid={k:v for k,v in sorted(paid.items())if v} + need(sum(targets.values())==11400 and sum(paid.values())==57339,'All independent originals and actual queries') + need(targets[4]==72 and targets[8]==7776 and paid[4]==702,'Partial helper physical jobs') + surplus=sum(k*v for k,v in targets.items())-sum(k*v for k,v in paid.items()) + need(surplus==753==old['rank_surplus'],'No new first-moment credit') + return {'targets':targets,'paid':paid,'rank_surplus':surplus, + 'thick_calls':calls,'thin_queries':1665,'original_fields':11400, + 'main_original_fields':3552,'helper_original_fields':7848} + +def certify(inv,params=None): + p=dict(PARAMS if params is None else params) + V,E=source_engines() + tail=V.tail(E,inv,p['tested'],p['uniform'],17,18,p['alpha_gap']) + c1=p['uniform']-p['cover_gap'];d=p['atom'];old=p['old_backend'] + ordinary=(1-d)*c1+d*old;b=p['admitted'] + need(p['tested']>p['uniform']>c1>0,'Tested/uniform/covered strict gaps') + need(d>ordinary>b>0 and d<1-ordinary,'Ordinary adapter, recurrence and stock costs') + need(p['prime_coefficient']>256/p['cover_gap'],'Actual bad-class fallback prime allowance') + comparison={'current_admitted':F('.0034'),'current_exact_ordinary':F('.0034363538396')} + old_c1=F('.003459')-F(1,2**18) + comparison['PR4697_fixed_C0_prime_saturated_sup']=old_c1/(1+old_c1-old) + gains={k:b/v-1 for k,v in comparison.items()} + need(gains['current_exact_ordinary']>F(1,1000),'At least0.1% actual ordinary improvement') + return {'params':p,'after_cover':c1,'ordinary_exact':ordinary,'admitted':b, + 'tail':tail,'comparators':comparison,'relative_gains':gains, + 'margins':{'adapter':d-ordinary,'ordinary_relaxation':ordinary-b, + 'stock':1-ordinary-d,'prime_allowance':p['prime_coefficient']-256/p['cover_gap']}, + 'WORD_changed':True,'new_whole_kappa':None, + 'scope':'Conditional ordinary BIT supplier only; main selected/complex result unchanged.'} + +def encode(x): + if isinstance(x,F):return str(x) + if isinstance(x,dict):return {str(k):encode(v)for k,v in x.items()} + if isinstance(x,(tuple,list)):return [encode(v)for v in x] + return x + +if __name__=='__main__': + inv=invoice(LOCAL,HELPERS);result=certify(inv) + print(json.dumps(encode({'invoice':inv,'certificate':result}),indent=2)) diff --git a/research/bit-compact-productive-controller/verify.py b/research/bit-compact-productive-controller/verify.py new file mode 100644 index 0000000000..5debab47bf --- /dev/null +++ b/research/bit-compact-productive-controller/verify.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Rebuild a mixed-helper BIT controller and its charged ordinary supplier. + +Apache-2.0. Prepared for ai-nanachi with substantial OpenAI Codex assistance. +Predecessor source code, word, frame, compiler and arithmetic are credited in +README.md and byte-pinned in SOURCES.json. No selected kappa is changed here. +""" +from pathlib import Path +from collections import Counter +from fractions import Fraction as F +from contextlib import redirect_stdout +import argparse,copy,gzip,hashlib,io,json,sys,tempfile +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +sys.path.insert(0,str(HERE)) +import local_word as L +import independent_native as I +import price +import global_word as G +import audit_stream as A + +def need(c,m): + if not c:raise ValueError(m) + +def authenticate(): + manifest=json.loads((HERE/'SOURCES.json').read_bytes()) + count=0 + for row in manifest['files']: + if row['usage']!='input':continue + p=ROOT/row['path'];raw=p.read_bytes() + need(not p.is_symlink(),'No source alias') + need(hashlib.sha256(raw).hexdigest()==row['sha256'],'Changed input '+row['path']) + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'], + 'Changed Git blob '+row['path']) + count+=1 + return count + +def bit_main_controller(): + V,_=price.source_engines();C=V.C + B,_=C.engines();p,a=16,7 + row=json.loads((price.THIN/'BIT-CONTROLLER.json').read_bytes()) + coeff,events,idles=B.physical_controller(p,C.keep_mask(p,a)) + coeff=C.specialize_bit(coeff,C.thick_stages(p)) + factor=B.simultaneous_monomial_factor(coeff) + need(factor==row['boundaries'],'All main physical coefficients and actual binary boundaries') + need(C.replay_events(row['physical_events'],p,'bit')==coeff,'Literal emitted native/query/idle events') + need(price.encode(C.inventories('bit',p,a,factor['diagonal_monomials'],idles))==row['invoice'], + 'Literal source invoice, all main, idle, helper, and copied-query jobs') + need(B.LOCAL==price.OLD_LOCAL,'Baseline local recursive calls') + need(row['invoice']['thick_calls']==18,'Separate eighteen local invocations') + # This is reuse of the existing phase, rational port and owned-query backend. + # Its native algorithm is unchanged; the new local word gets its own audit. + contact=V.native_contacts() + return {'main_columns':32*111,'pairs':p,'prefix':a,'calls':18,'thin_queries':1665, + 'native_backend':contact,'main_source_abi_unchanged':True} + +def mutations(word,frames,reference): + controls={} + def reject(name,w): + try:I.verify(w,frames,reference) + except (ValueError,KeyError,IndexError):controls[name]='REJECT';return + raise ValueError('Unrejected actual native corruption: '+name) + w=copy.deepcopy(word);w['start'][462]=1;reject('warm_partial_helper',w) + w=copy.deepcopy(word);w['final'][462]=1;reject('unpaid_rank8_helper_credit',w) + w=copy.deepcopy(word);w['start'][0]=0;reject('changed_SOURCE_version',w) + w=copy.deepcopy(word);del w['records'][next(i for i,e in enumerate(w['records'])if e[0]==0)] + reject('missing_paid_QUERY',w) + w=copy.deepcopy(word);w['records'][next(i for i,e in enumerate(w['records'])if e[0]==1)][3]=0 + reject('changed_actual_ADD',w) + w=copy.deepcopy(word);del w['records'][next(i for i,e in enumerate(w['records'])if e[0]==3)] + reject('unreturned_owned_copy',w) + return controls + +def run(): + inputs=authenticate() + with tempfile.TemporaryDirectory(prefix='compact-productive-')as temporary: + out=Path(temporary) + # Requalify the existing local word with its actual partial endpoints. + with redirect_stdout(io.StringIO()):local=L.build(ROOT,out,True) + word=json.loads(gzip.decompress((out/'WORD.json.gz').read_bytes())) + payload=json.dumps(word,sort_keys=True,separators=(',',':')).encode() + need(hashlib.sha256(payload).hexdigest()=='6f8516694bd0067897e91311fb16a749eea8fdd2eb3761bfa3f8eb2740d5c6a6', + 'Canonical regenerated local payload (not gzip container)') + frames=json.loads((ROOT/'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json').read_bytes())['frames'] + reference=json.loads(gzip.decompress((ROOT/'research/kappa-rebuild/bit/sources/pr589-regenerated/WORD.json.gz').read_bytes())) + forward=I.verify(word,frames,reference) + reverse=I.verify(word,frames,reference,True) + matchers=I.helper_matchers(word,frames) + controls=mutations(word,frames,reference) + global_dir=out/'global' + global_result=G.build(ROOT,out,global_dir) + stream=A.audit(ROOT,out,global_dir) + stream_controls={} + for name in ('duplicate_owner','full8_credit','omit_clear','wrong_nested_frame','source_write_in_lease'): + try:A.audit(ROOT,out,global_dir,name) + except ValueError:stream_controls[name]='REJECT' + else:raise ValueError('Unrejected expanded-stream corruption '+name) + main=bit_main_controller() + local_paid={int(k):v for k,v in local['forward']['paid_profile'].items()} + helpers={int(k):v for k,v in local['productive_helper_ranks'].items()} + inv=price.invoice(local_paid,helpers) + need(global_result['paid']==inv['paid']and global_result['targets']==inv['targets'], + 'Actual emitted global operator binds the complete price') + certificate=price.certify(inv) + # Whole-job matching is a proved identity at every positive multiplicity: + # S diag(I4,0) S^-1=P; the generic complete-GL cover pays the routes. + # It is not treated as a free same-ARRAY permutation or rank-only dispatch. + majorant_bits=max(local[k]['cancellation_free_majorant_bits']for k in ('forward','reverse')) + need(majorant_bits<=30,'New scalar majorant, not the predecessor21-bit bound') + return price.encode({'schema':'compact-partial-productive-BIT/1','status':'PASS_CONDITIONAL_ORDINARY_BIT_0034597', + 'source_inputs_authenticated':inputs,'local':{'forward':forward,'inverse':reverse, + 'exact_signed_inverse_both_orders':local['signed_inverse_both_orders'], + 'helper_matchers':matchers,'canonical_payload_sha256':hashlib.sha256(payload).hexdigest(), + 'scalar_majorant_bits':majorant_bits,'old_scalar_threshold_reused':False}, + 'main':main,'invoice':inv,'ordinary_BIT':certificate, + 'expanded':{k:global_result[k]for k in ('raw_scalar_columns','private_peak','private_episodes', + 'nonidentity_mainport_routes','additional_partial_outputmatcher_routes','event_counts', + 'expanded_event_count','expanded_event_sha256','cancellation_free_majorant_bits','raw_scalar_record_bound')}, + 'separate_stream_interpreter':stream,'expanded_negative_controls':stream_controls, + 'negative_controls':controls,'new_complex_or_global_kappa':None, + 'scope':'Finite all-column native schematic and conditional ordinary BIT supplier. Paid tensor completion/splitting, delayed-cover/fallback and stock are retained. New fixed constants must be generated from this word; no massive uniform word or global multiplication theorem is materialized.'}) + +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');args=p.parse_args() + result=run();target=HERE/'RESULT.json' + if args.write:target.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n',encoding='utf-8') + else:need(result==json.loads(target.read_bytes()),'Deterministic complete receipt') + print(json.dumps({'status':result['status'],'admitted_BIT':result['ordinary_BIT']['admitted'], + 'original_fields':result['invoice']['original_fields'], + 'native_controls':len(result['negative_controls'])}))