diff --git a/research/p104-retained-operand-descent/NOTICE b/research/p104-retained-operand-descent/NOTICE new file mode 100644 index 0000000000..e0b590250b --- /dev/null +++ b/research/p104-retained-operand-descent/NOTICE @@ -0,0 +1,123 @@ +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/p104-retained-operand-descent/PRICING-EDITS.json b/research/p104-retained-operand-descent/PRICING-EDITS.json new file mode 100644 index 0000000000..8b3cf4891f --- /dev/null +++ b/research/p104-retained-operand-descent/PRICING-EDITS.json @@ -0,0 +1,14 @@ +[ + [ + "KAPPA, TESTED = Q('0.003128386'), Q('0.0031283910')", + "KAPPA, TESTED = Q('0.003128645'), Q('0.003128650')" + ], + [ + "PREVIOUS = Q('0.003125804')", + "PREVIOUS = Q('0.003128386')" + ], + [ + "'kappa_decimal':'0.003128386','previous_pr6030':PREVIOUS", + "'kappa_decimal':'0.003128645','previous_pr6144':PREVIOUS" + ] +] diff --git a/research/p104-retained-operand-descent/PROOF.md b/research/p104-retained-operand-descent/PROOF.md new file mode 100644 index 0000000000..71d6a77e7c --- /dev/null +++ b/research/p104-retained-operand-descent/PROOF.md @@ -0,0 +1,114 @@ +# Retain an operand to remove a root stop + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source construction is PR6144 by DreamingOfClouds. See NOTICE for all +retained source credit. + +## Exact source and claim + +Use PR6144 at `5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417`. Under the same five +framework assumptions as the selected P104 result, the changed finite word and +complete caller support **κ = 0.003128645**. The proof has two parts: equality +of the changed local operation and a complete cost and compiler check. + +Event positions below are zero-based positions in the immutable source word. +The native frames have these dimensions and containments: + +```text +dim(3)=0, dim(595)=1, dim(737)=4, dim(520)=6; +3 ⊂ 595 ⊂ 737 ⊂ 520 ⊂ 529. +``` + +The checker proves these containments and the ranks through the unchanged +source replay and the exact native-map checker. No new frame is introduced. + +## Equality at the cut + +Let `a` be the decoded value of reader 451 before event 12918. Let `b` be the +decoded value of helper 228 at event 12918. Let `q` be the decoded root value +in register 772 at event 13485. The source performs: + +1. Move reader 451 from frame 3 to frame 737 and add `b` at event 12918. +2. Move root 772 from frame 520 to frame 737 at event 13486. +3. Add `-4q` to reader 451 at event 13487. +4. Move root 772 from frame 737 to frame 595 at event 13488. + +At this cut, reader 451 has value `a+b-4q` in frame 737. Root 772 has value `q` +in frame 595. No other register reads reader 451 between events 12918 and +13488. Its next external read is event 14524. + +The new word performs: + +1. Move reader 451 from frame 3 to frame 595 at event 12913. +2. At event 12918, initialize owned register 770 in frame 737 and copy `b` into + it. This uses the source value before helper 228 leaves that frame. +3. At event 13488, move root 772 directly from frame 520 to frame 595. Add + `-4q` to reader 451 in that frame. +4. Move reader 451 from frame 595 to frame 737, add the saved `b`, and clear + register 770. + +The value is now `a-4q+b = a+b-4q`. The two schedules give the same values and +frames for all public and live owned registers at the cut. The saved value is +zero on exit. Register 770 has no earlier live lifetime; its source lifetime +starts at event 13658. The new lifetime ends before that event. + +Each scalar operation acts in a common native chart. Each new MOVE has the +proper nested direction: public registers move to a containing frame and owned +registers move to a contained frame. The native checker verifies every signed +Pauli image and the exact global phase. Full arbitrary-input and +reverse-chronology transpose replays also check the complete word, including +all later reads and public restoration. + +## Complete bill + +The old three changed routes have ranks `4, 2, 3`. The new three routes have +ranks `1, 5, 3`. The rank-3 terms cancel. For `H_r=r^t` and `0 0. +``` + +Strict concavity gives the last inequality. The number of paid calls and rank +mass stay the same. All productive targets and all 104 main ports stay the +same. The complete caller has 18 local calls, so its paid change is +`18(H_1-H_2-H_4+H_5)`. The 15 thin-query groups, 3,120 whole idle jobs, main +adapters and helper normalizers retain their full charges. + +The full word has 22,821 events, 770 public registers, 29 owned register labels, +32 owned lifetimes and peak owned use 13. The new cache adds one INIT, one COPY +and one CLEAR. The local scalar allowance rises from 189,658 to 189,670. The +route bound is 5,325,000 and includes four route allowances for each owned +lifetime. Their sum is below the retained local budget of `10^7`. +The full nonrecursive bound is 184,647,552, below `10^9`. +The scalar-growth bound uses 26,000 events; the word remains below that bound. + +The complete invoice has 66,762 paid calls, 13,444 productive fields and rank +surplus 760. A separate census from the two caller path lengths agrees with +the physical-event census. No target is assigned to the new cache. + +## Price, completion and transfer + +The two exact rational moment engines give a unique raw crossing in + +```text +(0.00312865201590, 0.00312865201591). +``` + +The derivative bound is negative on the retained interval up to the BIT cap +0.0034. This ceiling is for this fixed invoice. The old PR6144 invoice has a +negative upper margin at the new claim. + +Use tested saving 0.003128650, cutoff 16, floor 17, tensor power 1024, tail +offset `1/7`, reserve `10^-12`, decay `125/128` and tail block 128. The paid, +offset and completion ratios have upper bounds below, respectively, +`1-10^-12`, `125/128` and `125/128`. Splitting and rounding charges are included. +The compiler gap is `1/1400000000`. The finite threshold is +`N = 2^65807000000000`; its integer threshold test rejects the preceding value. +All 54 strict outer inequalities and four functional inequalities pass. + +These checks retain the native-all-columns, owned-erasure, uniform-compiler, +precision/tape and analytic-recovery assumptions. They do not materialize the +uniform word or the rounded integer multiplier. Independent scientific review +remains open. The selected frontier is not changed. diff --git a/research/p104-retained-operand-descent/README.md b/research/p104-retained-operand-descent/README.md new file mode 100644 index 0000000000..cbe390b9e7 --- /dev/null +++ b/research/p104-retained-operand-descent/README.md @@ -0,0 +1,97 @@ +# Retained operand: conditional κ = 0.003128645 + +This package raises the conditional claim of +[PR6144](https://github.com/CrocSwap/integer-mult-bounds/pull/6144) +from **0.003128386 to 0.003128645**. The new gain is **0.000000259** +(about 0.00828%). This is a small gain from a changed paid profile. +The source is fixed at `5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417`. +The branch starts at canonical main `3f0152a32eeebac0df11946dbd50cabe5a7f7839`. + +The new operation order removes one stop from root register 772. Save helper +228 at frame 737 in register 770. Reader 451 can then receive the root at frame +595 before it adds that saved operand at frame 737. Clear the saved operand +before the existing use of register 770. All public outputs and productive +targets stay the same. The declared register count stays 29 and peak use stays +13. The extra lifetime and 12 scalar operations are charged. + +For `H_r = r^(1-κ)`, the local paid change is +`H_1 - H_2 - H_4 + H_5`. It is negative for `0 < κ < 1`. +The complete caller uses this change 18 times. It still has 66,762 paid calls, +13,444 productive fields and rank surplus 760. + +The raw crossing is strictly between **0.00312865201590** and +**0.00312865201591**. The claim leaves more than `7.01590e-9` of raw headroom. +The old PR6144 profile fails at the new claimed κ. This excludes an improvement +that comes only from a smaller rounding gap. + +## Evidence and scope + +[construct.py](construct.py) applies five guarded replacements to the pinned +source word. [PROOF.md](PROOF.md) proves the changed schedule and price. +[RESULT.json](RESULT.json) records the complete check. [VERIFY.json](VERIFY.json) +registers the replay. [VALIDATION.md](VALIDATION.md) records the environment and +the publication checks. + +The verifier checks the full regenerated payload, all 799 input columns, +638,401 endpoint coefficients, a separate transpose calculation, native maps +and exact phases, main adapters, helper normalization and the physical caller. +Two rational interval engines check the price. The completion, compiler and +all 54 strict plus four functional outer inequalities are checked. Controls +remove or change the cache, the later addition, restoration and cleanup. + +The five inherited assumptions remain: native operators at all column widths, +owned erasure, uniform compiler closure, precision and tape movement, and +analytic integer recovery. The uniform word at the stated threshold and the +rounded multiplier are not materialized. These are author checks. Independent +scientific acceptance remains open. The selected record stays at 0.003125804. + +## Reproduce + +Python 3.12 and its standard library are sufficient. From the repository root: + +```sh +python3.12 -I -B research/p104-retained-operand-descent/verify.py +python3.12 -I -O -B research/p104-retained-operand-descent/verify.py +python3.12 scripts/research_package.py --package research/p104-retained-operand-descent +``` + +Use `--build-only` on `verify.py` for the exact endpoint and inventory checks. +That option does not check the full native and compiler chain. The full command +does not need Git or network access. It authenticates every file in the retained +PR5827 source archive before use. Its local checker is unmodified. The price +equals PR6144's price with the three declared edits in +[PRICING-EDITS.json](PRICING-EDITS.json). + +Immutable input hashes stay exact. Regenerated gzip output is compared by every +decompressed payload byte, so different container headers are accepted. + +## Coordination and credit + +The canonical investigation is +[Discussion 5645](https://github.com/CrocSwap/integer-mult-bounds/discussions/5645#discussioncomment-19205459). +PR6144 explicitly left the reader 451/497 root-2 stop question open. This work +completes its reader 451 branch. The changed premise is a retained historical +operand and a changed addition order. The protected R22 and 102-contact event +sequences stay byte-exact. The overlap coverage and its limits are in +[TASK.json](TASK.json). + +New construction, proof and checks: Ali Romman, with substantial OpenAI Codex +assistance. PR6144 and PR6143 are by DreamingOfClouds with Claude Opus 5.5 +(Anthropic), via Claude Code. PR6030 and PR5907 retain that author's credit. +PR5827, PR5811, PR5802, PR5786 and their source authors retain all earlier credit. +The source reader follows DreamingOfClouds and Ali Romman. The portability +controls retain Douglas Colkitt and Maxime Fleury credit. [NOTICE](NOTICE) +retains the full source notices, including native, caller, compiler and BIT work. +All new work is Apache-2.0. + +## Open next questions + +- Can an independent reviewer confirm the changed chronology, full invoice and + complete replay? Start with the five replacements and the cache controls. + Author checks and hosted CI do not establish this acceptance. +- Can reader 497 avoid the remaining stop at frame 520? Its earlier operand at + frame 519 is an extra constraint: frame 595 is not a subspace of frame 519. + Start with an explicit paid schedule for both operands. A rank estimate or + an available historical span alone does not satisfy this task. + +The structured questions and their blockers are in [TASK.json](TASK.json). diff --git a/research/p104-retained-operand-descent/RESULT.json b/research/p104-retained-operand-descent/RESULT.json new file mode 100644 index 0000000000..9d78529c1a --- /dev/null +++ b/research/p104-retained-operand-descent/RESULT.json @@ -0,0 +1,388 @@ +{ + "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "complete_cost": { + "compiler": { + "H": 65807000000000, + "N": "2^65807000000000", + "eta": { + "lower": "0.000000118626899175019787449985", + "upper": "0.000000118626899175019787449986" + }, + "gap": "1/1400000000", + "integer_test_exponent": 47005, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "4380109/1400000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "259/1000000000", + "kappa": "625729/200000000", + "kappa_decimal": "0.003128645", + "margin_at_previous": { + "lower": "0.064187185057077484267832643894", + "upper": "0.064187185057077484267832643895" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one", + "source_completion": "Rejected at cutoff17, floor18 and decay39/40", + "source_offset": "Rejected at cutoff16 with tail offset1/5" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_paid_rank_mass": 5952, + "local_routes": 5325000, + "local_scalar": 189670, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 184647552, + "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "3066074897809947/980000000000000000", + "fused_gaussian": "3066074893429841/980000000000000000", + "global_coordinate_router": "4380107/1400000000", + "group_bit_router": "6132151186859679/1960000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "3066074197809947/980000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "401191074897809947/980000000000000000" + }, + "parameters": { + "a": "4380107/1400000000", + "b": "1095027/350000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "891191074197809947/980000000000000000", + "complex_uniform_saving": "4380109/1400000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "625729/200000000", + "lambda_": "398748541/400000000", + "lambda_prime": "697809947/700000000", + "layout": "1/1400000000", + "q": "2190053/700000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "62573/20000000" + }, + "strict_checks": { + "actual_bit_above_effective": "379893/1400000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "88808926852190053/490000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "2797809947/980000000000000000", + "cap_above_band": "401191074197809947/980000000000000000", + "cap_below_cell": "88808925102190053/980000000000000000", + "cap_below_phase_cell_power": "1068808925802190053/980000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "9842473/350000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793429841/980000000000000000", + "gaussian_above_main": "347809947/490000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "6986859679/1960000000000000000", + "group_gauge_power_slack": "88808926817190053/490000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "279123979/280000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "698837290400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "698904973/490000000000000000", + "leaf_saving_above_effective": "348904973/490000000000000000", + "main_transform_above_kappa": "2097809947/980000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "107795619901/1400000000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "174452487/175000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "698904973/490000000000000000", + "q_positive": "2190053/700000000", + "short_record_fallback": "348904973/350000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "398125002797809947/980000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 41448, + "16": 416, + "2": 8208, + "24": 416, + "3": 8928, + "32": 416, + "4": 1764, + "40": 416, + "48": 416, + "5": 2970, + "56": 416, + "6": 144, + "64": 416, + "7": 162, + "72": 208, + "8": 18 + }, + "paid_calls": 66762, + "previous_pr6144": "1564193/500000000", + "productive_fields": 13444, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-367468208829114694887602666313731272627044286101430142621984509/1569275433846670190958947355801916604025588861116008628224", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "70159/10000000000000", + "701591/100000000000000" + ], + "raw_root_interval": [ + "31286520159/10000000000000", + "312865201591/100000000000000" + ], + "relative_gain_percent": "12950/1564193", + "strictification": { + "alpha": { + "lower": "0.999999997959146219726397364394", + "upper": "0.999999997959146219726397364395" + }, + "cutoff": 16, + "delta": { + "lower": "0.950630412060446606438487179896", + "upper": "0.950630412060446606438487179897" + }, + "floor": 17, + "gamma": { + "lower": "0.975668301934073053974603857755", + "upper": "0.975668301934073053974603857756" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "125/128", + "tail_offset": "1/7", + "tested": "62573/20000000" + }, + "targets": { + "1": 252, + "145": 208, + "17": 416, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "41": 416, + "49": 416, + "5": 252, + "57": 416, + "6": 36, + "65": 416, + "7": 162, + "73": 208, + "8": 342, + "9": 6930 + }, + "whole_idle_jobs": 3120 + }, + "controls": { + "copy_after_source_departure": "Common scalar chart", + "damaged_base_word": "Exact source SHA256: research/p104-root-relay-descent-2/WORD.json.gz", + "damaged_pricing_source": "Exact source SHA256: research/p104-root-relay-descent-2/pricing.py", + "extra_target_credit": "Every productive helper has a native target", + "missing_cache_clear": "Owned initialization", + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "missing_copy": "All public and owned rows", + "missing_late_operand": "All public and owned rows", + "missing_reader_restoration": "Scalar destination and coefficient", + "missing_root_move": "Common scalar chart", + "unpaid_query": "Complete field and call counts", + "wrong_copy_sign": "All public and owned rows", + "wrong_root_coefficient": "All public and owned rows" + }, + "limits": [ + "All five inherited framework assumptions remain.", + "The large uniform word and rounded multiplier are not materialized.", + "Author checks do not establish independent acceptance.", + "The selected frontier is unchanged." + ], + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 14, + "6": 2, + "7": 9, + "8": 19, + "9": 385 + }, + "owned_fields": 29, + "owned_lifetimes": 32, + "paid": { + "1": 2216, + "2": 456, + "3": 496, + "4": 98, + "5": 165, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5952, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 189670 + }, + "native": { + "distinct_maps": 2922, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 14, + "6": 2, + "7": 9, + "8": 19, + "9": 385 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "6a06b7c2b1a1bf57fb8c4c9da08d38035647890b13b02286ef1dfe529ccf2a91", + "wrong_phase_rejected": true + }, + "paid_delta": { + "1": 1, + "2": -1, + "4": -1, + "5": 1 + }, + "physical_caller": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "source_local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 14, + "6": 2, + "7": 9, + "8": 19, + "9": 385 + }, + "owned_fields": 29, + "owned_lifetimes": 31, + "paid": { + "1": 2215, + "2": 457, + "3": 496, + "4": 99, + "5": 164, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5952, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 189658 + }, + "source_margin_upper_at_new_claim": "-95351097961096095041906837060068646444515696568914023059/1569275433846670190958947355801916604025588861116008628224", + "status": "PASS_P104_RETAINED_OPERAND_KAPPA_003128645" +} diff --git a/research/p104-retained-operand-descent/SOURCES.json b/research/p104-retained-operand-descent/SOURCES.json new file mode 100644 index 0000000000..0c574b6026 --- /dev/null +++ b/research/p104-retained-operand-descent/SOURCES.json @@ -0,0 +1,207 @@ +{ + "schema_version": 1, + "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ], + "source_archive": { + "local_path": "inputs/pr5827-source.tar", + "sha256": "7af5908a4d83e83e28f59523fd7494841f669b7295311cfdbc3027fa65c5826d", + "files": 23, + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "pr": 5827, + "package": "research/p104-unread-path-resynthesis" + }, + "archived_files": [ + { + "path": "research/p104-unread-path-resynthesis/LOCAL-EDITS.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 59, + "sha256": "c4d195bcf17209a129bacf5b8ebd311d475c44405feb040683f096858f87a987", + "git_blob": "f725d2bb87b3322512cb76eefbe3a9b26ece7176" + }, + { + "path": "research/p104-unread-path-resynthesis/NOTICE", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 6714, + "sha256": "fe02063ca48bf070303ac05f613ab1e6e4dd9ee62141f7e7012d855faf7b0c78", + "git_blob": "8fc3f76cc0d66f19c9abd7c7111ec69c73c0434d" + }, + { + "path": "research/p104-unread-path-resynthesis/PLAN.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 1030, + "sha256": "46bada733d461d7d5154ba5ede7d32697eaa00ab7380a0ceaf53324b9084d1a8", + "git_blob": "dc269304a438d39c9aa60256eb33c4d439fb378a" + }, + { + "path": "research/p104-unread-path-resynthesis/PRICING-EDITS.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 437, + "sha256": "7cec40c77056d30d879ff6752bf785ce1773c11e6c959cc8f33c351b828e3c8a", + "git_blob": "205de2990148e83bdac27aea49de593ffbefee0a" + }, + { + "path": "research/p104-unread-path-resynthesis/PROOF.md", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 6614, + "sha256": "16b1ba9b9468b097796d900ac04f9a278e09cba5ec9e08436b6e06ee066b385b", + "git_blob": "eae2e1b895284155a1485f240a0ad43a4b52c0aa" + }, + { + "path": "research/p104-unread-path-resynthesis/README.md", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 4574, + "sha256": "5f5026b41eb3f822652d4b41b5f4f81c4a285ac77d7ec34f41fabdbdad4b0252", + "git_blob": "e663d069442adfb224de108031f80b603180d873" + }, + { + "path": "research/p104-unread-path-resynthesis/RESULT.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 13257, + "sha256": "e437dd9fc7368de705cef8a9d27c6161f1b246f36e320e5c155dde89f88e16e2", + "git_blob": "e2e078df445d6c1b988cf926fed3bc7570a88237" + }, + { + "path": "research/p104-unread-path-resynthesis/SOURCES.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 8164, + "sha256": "b6aa6b569e76a7ab07f59e3d3c1204dad485bc9d6638211907a3f619073b6e33", + "git_blob": "4531538f264f4aaf9bd5e0d6be74758578fab749" + }, + { + "path": "research/p104-unread-path-resynthesis/TASK.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 7801, + "sha256": "2548bea7e62ee5d8b988c72988c7f8cf69ed623994e662929639ff857620942f", + "git_blob": "1b7c6ccdb6a32e89b11f70163e1b4b409f5693d6" + }, + { + "path": "research/p104-unread-path-resynthesis/VALIDATION.md", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 1790, + "sha256": "593470975c818bd86d3af813d86d8a6c17ef51c0e7e437e14a0c94de1286112c", + "git_blob": "1a3fa30e394a9837ec6d57adc019144ac323ea67" + }, + { + "path": "research/p104-unread-path-resynthesis/VERIFY.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 677, + "sha256": "c0c2995e2961dcad87e5f78fac22b519c629a1da77e661f924fa5101a87fde4d", + "git_blob": "988b0541663f9bddf08d3c80ff09cacd87d9ab4c" + }, + { + "path": "research/p104-unread-path-resynthesis/WITNESS.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 677, + "sha256": "6f9bb837e47c5b10f6d008d57a87415c7013e2076f3313fde1848d27b3314e67", + "git_blob": "969ff0c9b474bc9d2df2eec8482e17cfb75c1fbe" + }, + { + "path": "research/p104-unread-path-resynthesis/WORD.json.gz", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 122919, + "sha256": "5d50e5654910c9535e9025de0f644bb2dece2396e799b4a766110363448fd0b0", + "git_blob": "6341a49f717bd64ef2a5b7c440bd86d5513425dc" + }, + { + "path": "research/p104-unread-path-resynthesis/construct.py", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 2371, + "sha256": "e23a70d1fa000c05c6e05a6d8c909cd47b8aabc6c7505f925fc0235575076c9c", + "git_blob": "7d33cb8646ea7492131853070e97afd5935521da" + }, + { + "path": "research/p104-unread-path-resynthesis/inputs/pr5786-source.tar", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 3788800, + "sha256": "9ca76daeb8db6b623d7329628248fae114946f35fb036c3171fcdba868131dc2", + "git_blob": "a1f7e63c7dd3b5ef4cde70b96e8ad6aa30cdc684" + }, + { + "path": "research/p104-unread-path-resynthesis/inputs/pr5811-NOTICE", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 1027, + "sha256": "2f87017c7497194392d41c8ae80e5e1cfcf14651627cea2f918c1c8924c9858d", + "git_blob": "bd91106cde0cc8c201329bedc2d45af65c582b57" + }, + { + "path": "research/p104-unread-path-resynthesis/inputs/pr5811-PROOF.md", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 12191, + "sha256": "87756328c812a9076a55d5ebe1b9ea81d8fdcb166608cb39b0b43cca2cdc8593", + "git_blob": "71a8c020a59e8469cd547511766db92fa79480c4" + }, + { + "path": "research/p104-unread-path-resynthesis/inputs/pr5811-RESULT.json", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 19496, + "sha256": "2ba9ec0c06ce0c2683cdd704cacb63e6bb9afeb90a07a16fb63ec9e55696c488", + "git_blob": "2e73d97bdd2b2c13e05e66299722e0aa30c2d050" + }, + { + "path": "research/p104-unread-path-resynthesis/inputs/pr5811-WORD.json.gz", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 122915, + "sha256": "690656bfca9c6f0366527d158ca4edb14f83c410604d647953c20c7c94bea2e8", + "git_blob": "3633d78556932b1d66285c19d888fcd7c62cdbf1" + }, + { + "path": "research/p104-unread-path-resynthesis/local.py", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 9394, + "sha256": "7201df8e32f5c99f7403150e8664042322037906088bc754c67293a241368597", + "git_blob": "b7be846b10c4c54a4e1558d7b563bc8c3a170223" + }, + { + "path": "research/p104-unread-path-resynthesis/pricing.py", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 11028, + "sha256": "04b36429147f2809468d9ff037e26eaa70e66a5180e4b5c71a060bd5d14ffd9c", + "git_blob": "f2882694610b9bb49ddd7b6d99ccd628ae58be37" + }, + { + "path": "research/p104-unread-path-resynthesis/sources.py", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 2488, + "sha256": "f96de7d80f369c12f6f904b7935610979d59617ed0d49963841e86b9a2b45557", + "git_blob": "3b4c60838a43cb849707292bac144f14ad7fc8f1" + }, + { + "path": "research/p104-unread-path-resynthesis/verify.py", + "commit": "05cd36e5af06d7a3790e30ce3f449fa89b853768", + "size": 7142, + "sha256": "41f71fff49c041d44048652228c901221555762f7ff3e11a088aa270ce6820a7", + "git_blob": "2a4d91891374a872dbee92b86bd21ebfb305c029" + } + ], + "base_word": { + "path": "research/p104-root-relay-descent-2/WORD.json.gz", + "commit": "5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417", + "pr": 6144, + "local_path": "inputs/pr6144-WORD.json.gz", + "size": 119901, + "sha256": "c71985d96bf3d4a35aae111aaba87e376f7367efb4a5686278ef293732757533", + "git_blob": "69b70ee50c697b185ebf585fbe69f2487af32d1d" + }, + "pricing_source": { + "path": "research/p104-root-relay-descent-2/pricing.py", + "commit": "5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417", + "pr": 6144, + "local_path": "inputs/pr6144-pricing.py", + "size": 11017, + "sha256": "038c713b602adf3516260278ad4c79736b6b0548013e68b0bea2d1eb99a451f3", + "git_blob": "4fc2aaa55f4db587020cc8ae51edaffe1d95c770" + } +} diff --git a/research/p104-retained-operand-descent/TASK.json b/research/p104-retained-operand-descent/TASK.json new file mode 100644 index 0000000000..a2b53f5128 --- /dev/null +++ b/research/p104-retained-operand-descent/TASK.json @@ -0,0 +1,152 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. 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_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Retain the historical operand of reader451, change its addition order, remove root772 stop737 on exact PR6144, and verify the complete conditional caller and kappa.", + "scope_change_reason": "The current card asks for a helper basis split. The explicit PR6144 handoff and donor request instead select a changed causal schedule with fixed public targets. This scope uses a retained operand to change the scalar word.", + "bottleneck_link": "The new local paid profile replaces ranks2 and4 with1 and5. The complete18-call invoice improves at fixed productive targets, including the extra cache lifetime, scalar operations and routes.", + "budget_minutes": null, + "stop_rule": "Publish only after a strict improvement over the source complete profile, exact endpoint and native replay, full pricing and compiler checks, and portable replay with controls.", + "outcome": "completed", + "evidence": "construct.py, PROOF.md, WORD.json.gz, RESULT.json and VALIDATION.md", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance for research, construction, proof, verification and packaging. No subagents. Source PR6144 uses Claude Opus5.5 (Anthropic), via Claude Code; all predecessor notices are retained.", + "open_questions": [ + { + "question": "Does an independent reviewer confirm the retained operand schedule and complete conditional claim?", + "why_it_matters": "Author checks and CI do not establish scientific acceptance.", + "first_step": "Inspect the five replacements, then run the full verifier and cache corruption controls.", + "blocked_by": "Independent review and the five inherited framework assumptions remain open." + }, + { + "question": "Can reader497 avoid the remaining root stop at frame520?", + "why_it_matters": "This could extend the gain beyond the reader451 branch.", + "first_step": "Give a paid chronological schedule for both earlier operands. Check that frame595 is not contained in frame519.", + "blocked_by": "No complete cheaper schedule for both operands is supplied here." + } + ], + "coordination": { + "canonical_discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5645#discussioncomment-19205459", + "source_pr": 6144, + "source_commit": "5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417", + "overlap_checked_at": "2026-10-28T23:32:00Z", + "open_prs": 312, + "discussion_records": 5854, + "remote_pagination": "complete", + "local_notes": "Sparse checkout:9of8567 notes. Unpublished work is not covered.", + "scope_basis": "PR6144 explicitly leaves the reader451/497 root-2 stops open. Exact neighboring claims were read. Protected contact subsequences and other active families remain outside scope.", + "presubmit_refresh": { + "checked_at": "2026-10-29T00:20:17+00:00", + "canonical_main": "3f0152a32eeebac0df11946dbd50cabe5a7f7839", + "source_head_unchanged": true, + "coverage": "Latest20 open PRs and last8 comments in Discussions5125,5600,5645,5593,1166. The live5600 GF4 scope fixes the source scalar graph and excludes changed scalar words. The5593 caller scope is separate." + }, + "larger_proposals_read": [ + { + "pr": 5270, + "head": "225a19a184296d12120203a1f43b981d55465241", + "scope": "Draft p19 claim0.0033999964; this package does not claim to complete its caller." + }, + { + "pr": 5440, + "head": "c0f52b5b18bba78a6a5e8057edf9571bade88549", + "scope": "The larger p19 claim0.0033999964 explicitly retains the missing chain-to-native-event compiler contract and sets kappa_attached_to_physical_chain=false. This contribution instead extends the exact PR6144 native word. The live5593 caller scope is separate." + } + ] + } +} diff --git a/research/p104-retained-operand-descent/VALIDATION.md b/research/p104-retained-operand-descent/VALIDATION.md new file mode 100644 index 0000000000..66c3f4c00c --- /dev/null +++ b/research/p104-retained-operand-descent/VALIDATION.md @@ -0,0 +1,57 @@ +# Author validation + +Date: 2026-10-29 UTC. Host: macOS 26.6.1, arm64. Registered interpreter: +CPython 3.12.13. The package uses only the standard library. No subagents or +independent scientific reviewers performed these checks. + +## Completed checks + +- The immutable source word and price match their Git blob bytes at PR6144 + head `5ec9b6dafc1ec54e2c0ca0771e8ed032f7888417`. Their sizes, SHA256 hashes + and Git blob IDs are retained in SOURCES.json. The source archive and every + file in its dependency chain are authenticated by the direct verifier. +- `construct.py --write` generated the full 22,821-event word. +- `python3.12 -I -B verify.py --write` passed the full chain and wrote RESULT.json. +- `python3.12 scripts/research_package.py --package research/p104-retained-operand-descent` + passed all registered commands. These include seven gzip and source-integrity + controls and the complete replay in both ordinary and optimized Python modes. + Both modes reproduced the exact RESULT.json. +- The separate transpose covers 799 columns and 638,401 coefficients. The native + checker covers 2,922 distinct maps, exact phases, 208 main adapters and 1,124 + helper normalizers. The complete caller and all price, compiler and outer + checks passed. RESULT.json lists each semantic rejection control. +- The metadata and source-pin check passed after the metadata update. Runtime + inputs are inside this package. The two source-head files use the archive + reader's exact-byte contract; they do not require an unrelated PR branch in + a clean CI checkout. The generic provenance rows pin main's selected record + and task catalogue. +- Canonical main and the exact PR6144 head were refreshed before submission. + Both were unchanged. The latest scoped Discussion claims were read. The + live GF(4) frame assignment in Discussion 5600 fixes the scalar word and + expressly excludes changed scalar words. The caller work in 5593 is separate. + +## Publication checks + +The committed-byte and executable-mode preflight passed at source commit +`531df47159d3f9ee6652c1e0e46305cc30ca841d` for all 18 package files. The official +exporter and its separate archive check passed. The archive SHA256 is +`3f5f6e6a612aa18b28a3a3bd444085e39b3de07055ed09c7f86d124fd285a934`. + +The exported package then passed the full optimized Python 3.12.13 replay in +156.311 seconds. Git was absent from PATH. All exported files had mode 0444; +all export directories had mode 0555. Hash and mode inventories before and +after the run matched for all 19 files, including the export receipt. +Status: `PASS_READ_ONLY_GIT_FREE_EXPORT`. + +The next commit changes only this validation note and task coordination +metadata. It does not change code, source inputs, the word or RESULT.json. +Hosted CI and independent scientific review remain pending. The optional full +Git-history ancestry preflight is not run: this checkout is shallow, and the +runtime source is retained in authenticated local archives. + +## Limits + +All five inherited framework assumptions remain. The uniform word at +`N = 2^65807000000000` and the rounded multiplier are not materialized. +The current selected result is not changed. Local verification and source +integrity do not establish independent acceptance or a practical speedup. diff --git a/research/p104-retained-operand-descent/VERIFY.json b/research/p104-retained-operand-descent/VERIFY.json new file mode 100644 index 0000000000..cc7c831163 --- /dev/null +++ b/research/p104-retained-operand-descent/VERIFY.json @@ -0,0 +1,41 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_portability.py" + ], + "timeout_seconds": 30, + "checks": "Accept changed gzip headers and compression for generated output. Reject changed payloads, type substitutions, corrupt containers and altered immutable source bytes." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 500, + "checks": "Authenticate all source bytes; regenerate the full word; check arbitrary inputs, ownership, transpose, native maps and phases, physical caller, complete invoice, two rational engines, completion, compiler, outer inequalities and semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 500, + "checks": "Run the same complete check with Python assertions disabled and compare the exact retained result." + } + ] +} diff --git a/research/p104-retained-operand-descent/WORD.json.gz b/research/p104-retained-operand-descent/WORD.json.gz new file mode 100644 index 0000000000..f2d3f98964 Binary files /dev/null and b/research/p104-retained-operand-descent/WORD.json.gz differ diff --git a/research/p104-retained-operand-descent/construct.py b/research/p104-retained-operand-descent/construct.py new file mode 100644 index 0000000000..595a193746 --- /dev/null +++ b/research/p104-retained-operand-descent/construct.py @@ -0,0 +1,64 @@ +"""Retain one operand and change the order of two additions. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source word is by DreamingOfClouds (PR6144); see NOTICE for earlier credit. +The full-payload comparison follows Douglas Colkitt's portability repair. +""" +from copy import deepcopy +from pathlib import Path +import gzip +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from sources import base_word, need + +# These positions refer to the authenticated PR6144 word. +REPLACEMENTS = { + 12913: (["MOVE", 451, 3, 737, False], [ + ["MOVE", 451, 3, 595, False]]), + 12918: (["ADD", 451, 228, "1", 737], [ + ["INIT", 770, 737], ["COPY", 770, 228, "1", 737]]), + 13486: (["MOVE", 772, 520, 737, True], []), + 13487: (["ADD", 451, 772, "-4", 737], []), + 13488: (["MOVE", 772, 737, 595, True], [ + ["MOVE", 772, 520, 595, True], + ["ADD", 451, 772, "-4", 595], + ["MOVE", 451, 595, 737, False], + ["ADD", 451, 770, "1", 737], + ["CLEAR", 770, 737]]) +} + + +def construct(base): + """Return the full word after the five declared replacements.""" + word = deepcopy(base) + program = [] + for index, event in enumerate(base['program']): + if index in REPLACEMENTS: + expected, replacement = REPLACEMENTS[index] + need(event == expected, 'Exact source event at ' + str(index)) + program.extend(deepcopy(replacement)) + else: + program.append(deepcopy(event)) + word['program'] = program + need(len(program) == 22821, 'Exact new event count') + return word + + +def payload(value): + return (json.dumps(value, sort_keys=True, indent=2) + '\n').encode() + + +def matches_shipped(value, compressed): + return gzip.decompress(compressed) == payload(value) + + +if __name__ == '__main__': + word = construct(base_word()) + if '--write' in sys.argv: + (HERE / 'WORD.json.gz').write_bytes(gzip.compress(payload(word), mtime=0)) + need(matches_shipped(word, (HERE / 'WORD.json.gz').read_bytes()), + 'Complete regenerated word payload') + print('PASS_RETAINED_OPERAND_WORD') diff --git a/research/p104-retained-operand-descent/inputs/pr5827-source.tar b/research/p104-retained-operand-descent/inputs/pr5827-source.tar new file mode 100644 index 0000000000..1e10936044 Binary files /dev/null and b/research/p104-retained-operand-descent/inputs/pr5827-source.tar differ diff --git a/research/p104-retained-operand-descent/inputs/pr6144-WORD.json.gz b/research/p104-retained-operand-descent/inputs/pr6144-WORD.json.gz new file mode 100644 index 0000000000..69b70ee50c Binary files /dev/null and b/research/p104-retained-operand-descent/inputs/pr6144-WORD.json.gz differ diff --git a/research/p104-retained-operand-descent/inputs/pr6144-pricing.py b/research/p104-retained-operand-descent/inputs/pr6144-pricing.py new file mode 100644 index 0000000000..4fc2aaa55f --- /dev/null +++ b/research/p104-retained-operand-descent/inputs/pr6144-pricing.py @@ -0,0 +1,184 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +The paid A2 change is from zxv PR5643. The three helper relations are from +Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance. +The four interior basis changes are by Ali Romman with Codex assistance. +Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('0.003128386'), Q('0.0031283910') +PREVIOUS = Q('0.003125804') + + +def encode(x): + if isinstance(x,Q): + return str(x) + if isinstance(x,dict): + return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): + return [encode(v) for v in x] + return x + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter() + L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target') + for e in word['physical_events']: + counts[e[0]] += 1 + if e[0] == 'LOCAL': + L.need(e[3] is False, 'Every source invocation is forward') + paid.update(local['paid']) + targets.update(local['helpers']) + elif e[0] == 'QUERY_SHEAR': + paid[1] += 104 + elif e[0] == 'IDLE': + paid[8*len(e[2])] += 208 + main = Counter() + idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'}) + for e in word['physical_events']: + if e[0] == 'IDLE': + idle[8*len(e[2])] += 208 + L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank') + for term in word['diagonal']: + main[1+8*sum(term[1:])] += 104 + L.need(main == physical['main_targets'], 'Every main target has its full native phase') + targets.update(main) + L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census') + # Recount by the two path lengths, without using emitted main diagonals. + second_t = Counter({r:18*n for r,n in local['helpers'].items()}) + second_p = Counter({r:18*n for r,n in local['paid'].items()}) + second_t[145] += 208 + second_p[1] += 15*104 + for length in (7,8): + for j in range(1,length+1): + second_t[1+8*(j+1)] += 208 + second_p[8*(j+1)] += 208 + L.need((targets,paid) == (second_t,second_p), 'Independent full invoice') + L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks') + L.need(sum(targets.values()) == 13444 and sum(paid.values()) == 66762, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + alpha = E.divide(paid,target) + gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + reserve,decay = Q(1,10**12),Q(125,128) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target)) + L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count') + old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target)) + L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') + return encode({'kappa':KAPPA,'kappa_decimal':'0.003128386','previous_pr6030':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), + 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40', + 'source_offset':'Rejected at cutoff16 with tail offset1/5', + 'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-retained-operand-descent/pricing.py b/research/p104-retained-operand-descent/pricing.py new file mode 100644 index 0000000000..cd8220ca7a --- /dev/null +++ b/research/p104-retained-operand-descent/pricing.py @@ -0,0 +1,184 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. +Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. +The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. +Ali Romman's complete caller/price proof and all predecessor credit are retained. +The paid A2 change is from zxv PR5643. The three helper relations are from +Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance. +The four interior basis changes are by Ali Romman with Codex assistance. +Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('0.003128645'), Q('0.003128650') +PREVIOUS = Q('0.003128386') + + +def encode(x): + if isinstance(x,Q): + return str(x) + if isinstance(x,dict): + return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): + return [encode(v) for v in x] + return x + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter() + L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target') + for e in word['physical_events']: + counts[e[0]] += 1 + if e[0] == 'LOCAL': + L.need(e[3] is False, 'Every source invocation is forward') + paid.update(local['paid']) + targets.update(local['helpers']) + elif e[0] == 'QUERY_SHEAR': + paid[1] += 104 + elif e[0] == 'IDLE': + paid[8*len(e[2])] += 208 + main = Counter() + idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'}) + for e in word['physical_events']: + if e[0] == 'IDLE': + idle[8*len(e[2])] += 208 + L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank') + for term in word['diagonal']: + main[1+8*sum(term[1:])] += 104 + L.need(main == physical['main_targets'], 'Every main target has its full native phase') + targets.update(main) + L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census') + # Recount by the two path lengths, without using emitted main diagonals. + second_t = Counter({r:18*n for r,n in local['helpers'].items()}) + second_p = Counter({r:18*n for r,n in local['paid'].items()}) + second_t[145] += 208 + second_p[1] += 15*104 + for length in (7,8): + for j in range(1,length+1): + second_t[1+8*(j+1)] += 208 + second_p[8*(j+1)] += 208 + L.need((targets,paid) == (second_t,second_p), 'Independent full invoice') + L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks') + L.need(sum(targets.values()) == 13444 and sum(paid.values()) == 66762, 'Complete field and call counts') + L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') + return targets,paid,counts + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + alpha = E.divide(paid,target) + gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) + reserve,decay = Q(1,10**12),Q(125,128) + L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') + L.need(decay**128 < Q(1,16), 'Both tail decay blocks') + normalized = 1/(1+v*reserve)+Q(4,2**32) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target)) + L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count') + old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target)) + L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') + return encode({'kappa':KAPPA,'kappa_decimal':'0.003128645','previous_pr6144':PREVIOUS,'gain':KAPPA-PREVIOUS, + 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], + 'raw_headroom':[lower-KAPPA,upper-KAPPA], + 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), + 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], + 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', + 'local_paid_rank_mass':local['paid_rank_mass'], + 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40', + 'source_offset':'Rejected at cutoff16 with tail offset1/5', + 'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-retained-operand-descent/sources.py b/research/p104-retained-operand-descent/sources.py new file mode 100644 index 0000000000..bef6542243 --- /dev/null +++ b/research/p104-retained-operand-descent/sources.py @@ -0,0 +1,88 @@ +"""Authenticate PR6144's word (the base of the edit) and open PR5827's published package (the verifier chain) +before importing any of its code. + +Source reader by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +Adapted by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The archive format and per-file checks follow PR5827's own sources.py (Ali Romman, OpenAI Codex assistance). +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + import gzip + raw = Path(path).read_bytes() + return json.loads(gzip.decompress(raw) if str(path).endswith('.gz') else raw) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def authenticate(raw, pin): + need(len(raw) == pin['size'], 'Exact source size: ' + pin['path']) + need(sha256(raw).hexdigest() == pin['sha256'], 'Exact source SHA256: ' + pin['path']) + need(sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() == pin['git_blob'], + 'Exact source Git blob: ' + pin['path']) + + +@contextmanager +def sources(): + """Yield the directory of PR5827's extracted package (every file authenticated).""" + pins = json.loads((HERE / 'SOURCES.json').read_bytes()) + archive = pins['source_archive'] + path = HERE / archive['local_path'] + need(sha256(path.read_bytes()).hexdigest() == archive['sha256'], 'Exact source archive') + members = {p['path']: p for p in pins['archived_files']} + need(len(members) == len(pins['archived_files']) == archive['files'], 'Exact source inventory') + with tempfile.TemporaryDirectory(prefix='p104-base-source-') as directory: + root = Path(directory) + with tarfile.open(path, 'r:') as bundle: + seen = set() + for member in bundle.getmembers(): + name = PurePosixPath(member.name) + need(member.isfile() and not name.is_absolute() and '..' not in name.parts + and '\\' not in member.name and ':' not in member.name, + 'Regular relative source file') + need(member.name in members and member.name not in seen, 'Unique declared source file') + seen.add(member.name) + raw = bundle.extractfile(member).read() + authenticate(raw, members[member.name]) + target = root.joinpath(*name.parts) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(raw) + need(seen == set(members), 'Complete source archive') + yield root / archive['package'] + + +def source_bytes(key): + pin = read(HERE / 'SOURCES.json')[key] + raw = (HERE / pin['local_path']).read_bytes() + authenticate(raw, pin) + return raw + + +def base_word(): + """PR6144's WORD.json.gz payload, authenticated against the exact source-head pin in SOURCES.json.""" + import gzip + pin = json.loads((HERE / 'SOURCES.json').read_bytes())['base_word'] + raw = (HERE / pin['local_path']).read_bytes() + authenticate(raw, pin) + return json.loads(gzip.decompress(raw)) diff --git a/research/p104-retained-operand-descent/test_portability.py b/research/p104-retained-operand-descent/test_portability.py new file mode 100644 index 0000000000..8739c2e0cf --- /dev/null +++ b/research/p104-retained-operand-descent/test_portability.py @@ -0,0 +1,88 @@ +"""Regenerated-output portability controls; immutable inputs stay exact. + +Maintainer repair by Douglas Colkitt with OpenAI Codex assistance. +Adapted for this construction by Ali Romman with OpenAI Codex assistance. +Construction source: DreamingOfClouds; retained predecessors in NOTICE. +Apache-2.0. +""" +from copy import deepcopy +import gzip +import io +import json +from pathlib import Path +import sys +import unittest +import zlib + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from construct import matches_shipped, payload +from sources import authenticate + + +class WordPortabilityTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.shipped = (HERE / 'WORD.json.gz').read_bytes() + cls.word = json.loads(gzip.decompress(cls.shipped)) + + def test_original_word(self): + self.assertTrue(matches_shipped(self.word, self.shipped)) + + def test_os_header_variants(self): + # Byte 9 is gzip's OS field. Neither the payload nor CRC changes. + for code in (0, 3, 19, 255): + changed = bytearray(self.shipped) + changed[9] = code + with self.subTest(os_code=code): + self.assertTrue(matches_shipped(self.word, bytes(changed))) + + def test_compression_timestamp_and_filename(self): + for level in (1, 6, 9): + with self.subTest(level=level): + buffer = io.BytesIO() + with gzip.GzipFile(filename='different-name.json', mode='wb', + compresslevel=level, mtime=1700000000, + fileobj=buffer) as stream: + stream.write(payload(self.word)) + self.assertNotEqual(buffer.getvalue(), self.shipped) + self.assertTrue(matches_shipped(self.word, buffer.getvalue())) + + def test_changed_event_and_unknown_field_rejected(self): + changed = deepcopy(self.word) + changed['program'].pop() + self.assertFalse(matches_shipped(changed, self.shipped)) + changed = deepcopy(self.word) + changed['unexpected_proof_field'] = 1 + self.assertFalse(matches_shipped(changed, self.shipped)) + + def test_boolean_is_not_an_integer(self): + changed = deepcopy(self.word) + move = next(event for event in changed['program'] if event[0] == 'MOVE') + self.assertIs(type(move[4]), bool) + move[4] = int(move[4]) + # Python object equality alone would silently accept this mutation. + self.assertEqual(changed, self.word) + self.assertFalse(matches_shipped(changed, self.shipped)) + + def test_extra_payload_and_corrupt_container_rejected(self): + self.assertFalse(matches_shipped(self.word, gzip.compress(payload(self.word) + b' '))) + self.assertFalse(matches_shipped(self.word, self.shipped + gzip.compress(b'not a word'))) + for bad in (self.shipped[:20], self.shipped[:-8] + b'\0' * 8): + with self.subTest(size=len(bad)): + with self.assertRaises((gzip.BadGzipFile, EOFError, zlib.error)): + matches_shipped(self.word, bad) + + def test_immutable_source_still_uses_exact_bytes(self): + pin = json.loads((HERE / 'SOURCES.json').read_bytes())['base_word'] + raw = (HERE / pin['local_path']).read_bytes() + authenticate(raw, pin) + changed = bytearray(raw) + changed[9] = 3 if raw[9] != 3 else 19 + self.assertEqual(gzip.decompress(raw), gzip.decompress(changed)) + with self.assertRaises(ValueError): + authenticate(bytes(changed), pin) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/research/p104-retained-operand-descent/verify.py b/research/p104-retained-operand-descent/verify.py new file mode 100644 index 0000000000..6003206a21 --- /dev/null +++ b/research/p104-retained-operand-descent/verify.py @@ -0,0 +1,164 @@ +"""Check the retained operand, native word, complete price and compiler. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source chain and price follow PR6144 by DreamingOfClouds and PR5827 by +Ali Romman. NOTICE retains the earlier construction and checker credits. +""" +from collections import Counter +from contextlib import ExitStack +from copy import deepcopy +from pathlib import Path +import json +import sys +import tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from sources import sources, source_bytes, base_word, load, need, read, authenticate +from construct import construct, matches_shipped + +STATUS = 'PASS_P104_RETAINED_OPERAND_KAPPA_003128645' +PROTECTED = {41, 42, 65, 106, 240, 400, 401, 403, 405, 410, 741, + 57, 81, 92, 224, 225, 227, 229, 234, 742} + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid control accepted') + + +def protected_events(word): + return [e for e in word['program'] if e[1] in PROTECTED or + (e[0] in ('ADD', 'COPY') and e[2] in PROTECTED)] + + +def word_controls(L, word): + out = {} + edits = [ + ('missing_copy', ['COPY', 770, 228, '1', 737], None), + ('wrong_copy_sign', ['COPY', 770, 228, '1', 737], + ['COPY', 770, 228, '-1', 737]), + ('wrong_root_coefficient', ['ADD', 451, 772, '-4', 595], + ['ADD', 451, 772, '-2', 595]), + ('missing_root_move', ['MOVE', 772, 520, 595, True], None), + ('missing_reader_restoration', ['MOVE', 451, 595, 737, False], None), + ('missing_late_operand', ['ADD', 451, 770, '1', 737], None), + ('missing_cache_clear', ['CLEAR', 770, 737], None)] + for label, event, replacement in edits: + bad = deepcopy(word) + need(bad['program'].count(event) == 1, 'Unique control event: ' + label) + index = bad['program'].index(event) + bad['program'][index:index+1] = [] if replacement is None else [replacement] + out[label] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + copy = ['COPY', 770, 228, '1', 737] + bad['program'].remove(copy) + index = bad['program'].index(['ADD', 451, 770, '1', 737]) + bad['program'].insert(index, copy) + out['copy_after_source_departure'] = reject(lambda: L.replay(bad)) + return out + + +def run(build_only): + with ExitStack() as contexts: + parent = contexts.enter_context(sources()) + cursor = contexts.enter_context(load(parent / 'sources.py', 'base_source_top').sources()) + for depth in range(7): + module = load(cursor / 'sources.py', 'base_source_' + str(depth)) + cursor, root = contexts.enter_context(module.sources()) + text = source_bytes('pricing_source').decode() + for old, new in read(HERE / 'PRICING-EDITS.json'): + need(text.count(old) == 1, 'Unique declared pricing edit') + text = text.replace(old, new) + need(text == (HERE / 'pricing.py').read_text(), 'Exact declared pricing edits') + L = load(parent / 'local.py', 'local') + L.ROOT = root + source = base_word() + word = construct(source) + need(matches_shipped(word, (HERE / 'WORD.json.gz').read_bytes()), + 'Every regenerated payload byte') + need(all(type(e[4]) is bool for e in word['program'] if e[0] == 'MOVE'), + 'Boolean ownership flags') + need(protected_events(word) == protected_events(source), 'Protected contact events unchanged') + baseline, local = L.replay(source), L.replay(word) + need(local['helpers'] == baseline['helpers'], 'All productive targets unchanged') + paid_delta = Counter(local['paid']) + paid_delta.subtract(baseline['paid']) + paid_delta = {r: n for r, n in paid_delta.items() if n} + need(paid_delta == {1: 1, 2: -1, 4: -1, 5: 1}, 'Exact local paid change') + need(tuple(local[k] for k in ('public_inputs', 'owned_fields', 'owned_lifetimes', + 'peak_owned_fields', 'real_scalar_allowance')) == + (770, 29, 32, 13, 189670), 'Exact storage and scalar inventory') + need(local['owned_lifetimes'] == baseline['owned_lifetimes'] + 1 and + local['real_scalar_allowance'] == baseline['real_scalar_allowance'] + 12, + 'Charge the added cache lifetime and scalar work') + print('PASS regeneration, arbitrary inputs, ownership and paid change', flush=True) + if build_only: + return None + columns = L.reverse_columns(word) + need(columns['columns'] == 799 and columns['coefficients'] == 638401, + 'Every input column and output coefficient') + print('PASS separate dense transpose', flush=True) + native = L.native(word) + C = load(root / 'research/p104-productive-controller/caller.py', 'base_caller') + caller = C.construct() + need(caller == read(root / 'research/p104-productive-controller/CONTROLLER.json'), + 'Exact physical caller') + physical = C.physical(caller, word) + print('PASS native maps, absolute phases and complete physical caller', flush=True) + P = load(HERE / 'pricing.py', 'retained_operand_price') + price = P.run(local, native, caller, physical) + need(price['raw_root_interval'] == + ['31286520159/10000000000000', '312865201591/100000000000000'], + 'Exact rational crossing interval') + E = L.load(root / 'research/higher-moment-strictification/verify.py', 'base_price_engine') + old_paid = {int(r): n for r, n in price['paid'].items()} + targets = {int(r): n for r, n in price['targets'].items()} + for rank, count in paid_delta.items(): + old_paid[rank] -= 18 * count + old_margin = E.moment(targets, 1 - P.KAPPA)[1] - E.moment(old_paid, 1 - P.KAPPA)[0] + need(old_margin < 0, 'The full PR6144 profile fails at the new claim') + controls = word_controls(L, word) + controls.update(C.controls(caller)) + bad = deepcopy(local) + bad['paid'][1] -= 1 + controls['unpaid_query'] = reject(lambda: P.assemble(bad, native, caller, physical)) + bad = deepcopy(local) + bad['helpers'][9] += 1 + controls['extra_target_credit'] = reject(lambda: P.assemble(bad, native, caller, physical)) + for key in ('base_word', 'pricing_source'): + pin = read(HERE / 'SOURCES.json')[key] + raw = (HERE / pin['local_path']).read_bytes() + controls['damaged_' + key] = reject( + lambda raw=raw, pin=pin: authenticate(bytes([raw[0] ^ 1]) + raw[1:], pin)) + print('PASS two interval engines, all costs, compiler, outer checks and controls', flush=True) + return P.encode(dict( + status=STATUS, base_commit=read(HERE / 'SOURCES.json')['base_commit'], + source_local=baseline, local=local, paid_delta=paid_delta, + separate_columns=columns, native=native, physical_caller=physical, + complete_cost=price, source_margin_upper_at_new_claim=old_margin, + controls=controls, + limits=['All five inherited framework assumptions remain.', + 'The large uniform word and rounded multiplier are not materialized.', + 'Author checks do not establish independent acceptance.', + 'The selected frontier is unchanged.'])) + + +def main(): + with tempfile.TemporaryDirectory(prefix='retained-operand-bytecode-') as cache: + sys.pycache_prefix = cache + result = run('--build-only' in sys.argv) + if result is not None: + if '--write' in sys.argv: + (HERE / 'RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + else: + need(read(HERE / 'RESULT.json') == result, 'Exact retained result') + print(STATUS + ('_BUILD' if result is None else ''), flush=True) + + +if __name__ == '__main__': + main()