From 08f0e5899254aa82288a91e70789049dc1f29690 Mon Sep 17 00:00:00 2001 From: Richard Hoekstra <741397+RichardHoekstra@users.noreply.github.com> Date: Mon, 26 Oct 2026 19:37:07 +0100 Subject: [PATCH] witness(research): reduce PR5413 carrier height at fixed saving Why: Evaluate the complete paid higher-moment charge and reapply tuple-sensitive precision and conjunction gates to expose smaller sufficient carriers without claiming practical runtime. Refs: PR5413, PR5468, higher-moment-strictification --- .../pr5413-carrier-frontier/.gitattributes | 1 + research/pr5413-carrier-frontier/NOTICE | 16 + research/pr5413-carrier-frontier/PROOF.md | 134 ++ research/pr5413-carrier-frontier/README.md | 127 ++ research/pr5413-carrier-frontier/RESULT.json | 1780 +++++++++++++++++ research/pr5413-carrier-frontier/SOURCES.json | 888 ++++++++ research/pr5413-carrier-frontier/TASK.json | 106 + research/pr5413-carrier-frontier/VERIFY.json | 176 ++ .../pr5413-carrier-frontier/application.py | 194 ++ research/pr5413-carrier-frontier/frontier.py | 161 ++ research/pr5413-carrier-frontier/verify.py | 227 +++ 11 files changed, 3810 insertions(+) create mode 100644 research/pr5413-carrier-frontier/.gitattributes create mode 100644 research/pr5413-carrier-frontier/NOTICE create mode 100644 research/pr5413-carrier-frontier/PROOF.md create mode 100644 research/pr5413-carrier-frontier/README.md create mode 100644 research/pr5413-carrier-frontier/RESULT.json create mode 100644 research/pr5413-carrier-frontier/SOURCES.json create mode 100644 research/pr5413-carrier-frontier/TASK.json create mode 100644 research/pr5413-carrier-frontier/VERIFY.json create mode 100644 research/pr5413-carrier-frontier/application.py create mode 100644 research/pr5413-carrier-frontier/frontier.py create mode 100644 research/pr5413-carrier-frontier/verify.py diff --git a/research/pr5413-carrier-frontier/.gitattributes b/research/pr5413-carrier-frontier/.gitattributes new file mode 100644 index 0000000000..0000fc00d7 --- /dev/null +++ b/research/pr5413-carrier-frontier/.gitattributes @@ -0,0 +1 @@ +* -text -filter diff --git a/research/pr5413-carrier-frontier/NOTICE b/research/pr5413-carrier-frontier/NOTICE new file mode 100644 index 0000000000..1e1cbd1077 --- /dev/null +++ b/research/pr5413-carrier-frontier/NOTICE @@ -0,0 +1,16 @@ +PR5413 carrier size-saving frontier +Copyright 2026 Richard Hoekstra +New package material is provided under the repository's Apache License 2.0. +Prepared with substantial OpenAI Codex assistance. + +This package reuses authenticated public arithmetic and application sources: +Chris R / Clear1nsight's PR5413 caller audit, exact moments, precision checker +and conjunction; zxv's higher-moment/logarithmic compiler and precision work; +Jacob Alan Sussman's integer mixed-target flow; Cinna Davis's product/helper +lineage; Dillon Amburgey's provider; Ali Romman's direct controller; Cao Yifan's +native construction; and the cumulative BIT, Clifford, analytic and verification +contributors credited in those frozen packages. PR5468's gap-parametric checker +provides related precedent but is not a dependency or a changed-tuple admission. + +No third-party source files are copied into this package. Public dependencies +retain their original notices and are declared and authenticated by exact paths. diff --git a/research/pr5413-carrier-frontier/PROOF.md b/research/pr5413-carrier-frontier/PROOF.md new file mode 100644 index 0000000000..5a1148d936 --- /dev/null +++ b/research/pr5413-carrier-frontier/PROOF.md @@ -0,0 +1,134 @@ +# Changed-tuple carrier application to the frozen PR5413 caller + +This is a conditional application of the existing higher-moment and logarithmic +compiler theorems. The raw native word, all-column/owner contracts and the five +selected framework assumptions remain premises. No new raw profile or root is +claimed. Source paths, exact Git blobs and SHA256 are in SOURCES.json. + +## 1. Complete paid charge + +The source has 10,928 productive fields, 64,260 paid jobs and ambient rank 145. +For raw moments T_t and P_t, tested saving s, t=1-s, u>=s and integer v>=1, put + +``` +alpha=P_t/T_t, +gamma=P_(t+u)/(c^u*T_t), +delta=10928*b/(c^s*T_t), 1J, the final incomplete split block +is included in `q*J^t+r^t<=2*R*J^(-s)`; the higher moment is valid because +`t+u>=1`. Completion includes the same final-block allowance and every owner. +The final productive moment is at least the raw T_t^v, so normalization by that +smaller quantity is conservative. No new field or unpaid child is introduced. + +The old `.97` bounds and `4/2^32` debit were sufficient upper estimates of those +same charged jobs. The new certificate evaluates all three terms directly with +outward rational bounds. It does not add the old sufficient debit as a second +copy of physical work. In particular the fixed-kappa point has gamma>.97 but +its full paid bound is still strictly below one. The source's old conjunction +correctly rejects that point; its changed application is explicit here. + +The public `exact_moments.py` helper is authenticated and reused with attribution, +not called an independent implementation. Its rational logarithm/exponential +enclosures are rounded outward before integer powers; each positive paid term +is rounded upward again, and their exact sum must be below one. + +## 2. Logarithmic majorant + +For theta=A/D<1, the inherited theorem requires + +``` +c^D < b^A, +2^(D-A)*c^(v*D) <= 145^(v*A), +theta^p < (1-s)*145^(-v*s), +145^(v*s) < 2^p, p a positive integer. +``` + +All are checked with integers or directed rational bounds. They imply the +source compiler's normalized leaf bound +`L(n)<=n^(1-s)*(1+log2 n)^p`. For declared saving k use the inherited slack +family d=(s-k)/7, uniform=k+6d, b_outer=k+5d, a_outer=k+4d, q_outer=k+3d, +epsilon=1-d, beta=1-3d, r0=d/10 and stop=layout=d. The actual source ledger's +54 strict predicates, four functional guards and nine cost rows are recomputed. +The ordinary BIT saving .0034 and atom .004 remain fixed and funded. + +## 3. A rational-gap carrier grid + +Set `H_j=ceil(j/d)` for positive integers j. A successful grid point obeys +`H_j>8v` and `(H_j+1)^p<2^j<=2^(d*H_j)`. Thus at N=2^H_j the leaf bound is +strictly below `N^(1-s+d)=N^(1-uniform)`. The new construction does not require +the numerator of d to be one; every rank and program count remains integral. + +For the implemented domain `0=1/d>16`, hence `(H_j+1)^p>2^(4p)>=2^j`. +- For `j>=4p`, `H_(j+1)-H_j<=ceil(1/d)`. Therefore + `(H_(j+1)+1)/(H_j+1)<=1+(1+d)/j`. Raising this ratio to p gives less than + `exp(17/64)<2`, using `log 2>1/2`. The left comparison grows by less than + two while the right comparison doubles. Once the grid succeeds it stays + successful, and the preceding tested grid point fails exactly. + +No minimal integer H, global compiler optimum or maximal kappa is claimed. + +## 4. Fresh finite-template and precision application + +The original V16 application proof already counts the actual source's 145-axis +maps, 418 private fields, scalar/ordinary records and dyadic coefficient height +below A0=2^128. Those data and all raw source/field-ID/route bindings are unchanged. +For product v, the same strictified-unit overestimate becomes + +``` +2*(v*(2+2*128)+10+2*(8v))+6+3*(8v+1)=572v+29. +``` + +It remains below 1048576 on the declared v<=1024 domain. Keep the conservative +original `D0=2^1048576`, and reapply exactly the same constructive F16 recursion +at the new N. No count from the raw template is silently reused as an expanded +count. The resulting M=F16(N) bounds W,P,U,O,R,G, with the source's updated +ordinary/precision/parked-stock prescriptions. D0 and M enter eventual outer +constants, not a claim that they fit below N^d. All relevant outer gaps remain +strict. The tensor product, paid completion and disjoint splitting are the +retained finite algorithm, including their complete owners and whole-job adapters. + +`application.py` verifies seven numerical substitution sites in the accepted +V16 proof and inserts the preceding complete-charge/grid application paragraph. +It builds each full instance only in scratch and binds its SHA256 in the source +and conjunction manifests. The generated precision checker changes three exact +source sites: product/ambient-log parameters, positive rational gap, and the +positive-power ceiling-grid checks. On the original manifest it reproduces the +entire original precision payload except timing/checker/manifest hashes. + +The conjunction adapter changes six named applications: endpoint/gap, complete +moment funding, partial-block charging, carrier grid, fresh F16 count bound and +the instantiated proof hash. The old fixed-envelope minimum-reserve gate becomes +an explicit complete paid-sum gate. The other 19 conditions are compared in the +AST and stay unchanged, including complete profile equality, actual owners, +all-column source packet/phase/route bindings, ordinary BIT/stock and component +false flags. All 25 adapted conditions pass for each point. This is a new +conditional application receipt, not an upstream approval or proof-kernel result. + +## 5. Replay coverage and remaining premises + +Every registered replay first runs the unchanged complete PR5413 eight-engine +master and compares its frozen outputs. Those source-identical native, local, +whole-caller, field-ID and invoice results are reused across the five new tuples. +Each tuple then has fresh directed funding, full outer checks, generated written +application, precision check and conjunction. Meaningful controls reject the old +coarse application, a preceding carrier grid, product outside the declared safe +domain, a missing paid job, free completion and an invalid higher-moment offset. + +The five premises are unchanged: native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. No uniform word or physical Turing tape is +materialized, no independent human verification is claimed, and no practical +runtime improvement follows from the smaller sufficient carrier. + +Credit the source higher-moment/log compiler to zxv; mixed-target flow to Jacob +Alan Sussman; chronological products/completion and helpers to Cinna Davis and +the retained lineage; PR5413 application/checkers to Chris R/Clear1nsight, using +Dillon Amburgey's provider, Ali Romman's controller and Cao Yifan's native word. +Richard Hoekstra prepared this application with OpenAI Codex assistance. +New work is Apache-2.0; source-specific notices remain in the frozen inputs. diff --git a/research/pr5413-carrier-frontier/README.md b/research/pr5413-carrier-frontier/README.md new file mode 100644 index 0000000000..7c46de02c3 --- /dev/null +++ b/research/pr5413-carrier-frontier/README.md @@ -0,0 +1,127 @@ +# Smaller PR5413 carriers at fixed saving, with certified size-saving tradeoffs + +For the unchanged complete PR5413 raw caller, the sufficient height H in N=2^H +falls **3.20324× at exactly the same conditional κ=.003027288235**. Four +explicitly weaker declared savings give smaller carriers, including a +31.1-million-fold H reduction at κ=.003. These compare sufficient construction +bounds, not measured multiplication runtimes or globally minimal templates. +The selected frontier, raw profile, raw root and five framework assumptions +are unchanged. No practical-size word or full unconditional theorem is claimed. + +| Declared κ | Product v | Log power p | Sufficient H | PR5413 H / H | +| --- | ---: | ---: | ---: | ---: | +| Published .003027288235 | 1024 | 1000 | 38569300000000000 | 1 | +| Same .003027288235 | 1024 | 322 | 12040700000000000 | 3.20324 | +| .003 | 512 | 120 | 1239850102 | 31108034.7 | +| .00275 | 256 | 59 | 50859231 | 758353975 | +| .0025 | 256 | 58 | 25258797 | 1526965041 | +| .002 | 256 | 55 | 11738348 | 3285751964 | + +The κ=.003 point retains about 99.1% of the PR5413 exponent saving. The large +height factors at lower κ explicitly spend exponent headroom; they do not +preserve the original exponent. Even the smallest carrier remains astronomical. + +## What changes and what is reused + +The fixed-κ tuple uses cutoff18/floor21, higher-moment offset1/10, +theta61/64 and logarithm power322. The lower-saving tuples use cutoff17/floor21, +offset1/10 and theta15/16, with the exact tested exponents in [RESULT.json](RESULT.json). +All 64,260 paid jobs and 10,928 productive fields of the raw caller are retained. + +The existing higher-moment theorem pays the complete normalized sum +`alpha^v+2*gamma^v+2*delta^v`. Evaluating that sum directly replaces the old +sufficient `.97`/Bernoulli tail envelope and permits the changed tuple. Both +partial-block remainders and all target completions stay charged. It is not +enough to substitute a smaller logarithmic power in the old pinned checker. + +The existing logarithmic compiler and positive slack family then fund the new +carrier. [PROOF.md](PROOF.md) gives the complete charge, rational-gap ceiling +grid, fresh finite-template application and remaining assumptions. [application.py](application.py) +makes the exact source substitutions in scratch. It generalizes three precision +sites, checks conservativity on the original payload, and changes six named +conjunction applications. The other **19 of 25 source conditions are unchanged +in the AST**, including all owner/phase/route/field-ID checks and false component +flags. All 25 adapted conditions pass for each new point. The one old minimum +reserve-envelope gate is explicitly replaced by a full paid-sum condition. + +Every replay first runs the **unmodified complete eight-engine PR5413 master**. +Its source-identical native/local/wholecaller/binding/invoice evidence is reused +across the five tuples; funding, outer inequalities, precision and conjunction +are fresh for each tuple. Frozen source files are never edited. The original +arithmetic helpers and outer ledger are authenticated and reused with credit; +this package does not claim an independent implementation of those helpers. + +Meaningful controls reject the unsubstituted coarse application, a preceding +height grid, product outside the declared safe domain, a missing paid job, +free completion and an invalid higher-moment offset. All 54 strict and four +functional outer predicates remain funded. Component flags retain their narrow +scope; a successful adapted conjunction is not upstream scientific approval. + +## Relation to previous work + +zxv's higher-moment/logarithmic compiler already reduced earlier sufficient +carriers substantially. PR5468 supplies gap-parametric precision on the same +caller with the original tuple fixed. This contribution applies a changed +fully charged tuple at fixed κ and records a size-saving frontier, rather +than more digits of the raw root. It is neither a new strictification theorem +nor the first parametric precision application. The raw native/provider/ +controller and complete conditional-framework lineage keep full credit. + +This was an explicitly assigned finite-size investigation. Its changed scope +from the historical `independent-moment` card is in [TASK.json](TASK.json). +Exact base/source blobs and hashes are in [SOURCES.json](SOURCES.json); the +current selection and catalogue are historical provenance. A bounded public +PR-title/body search included PR5413/5462/5468 and the exact new H value; it +is not an exhaustive novelty proof. No selected-record update is requested. + +## Reproduce and inspect + +Python standard library only; generic environment Python 3.12. From repo root: + +```sh +python3 -B scripts/research_package.py --package research/pr5413-carrier-frontier --check-only +python3 -B scripts/research_package.py --package research/pr5413-carrier-frontier +``` + +To retain each generated full written application and exact precision/conjunction +review diff, with no frozen-source edits: + +```sh +python3 -I -B research/pr5413-carrier-frontier/verify.py \ + --proof-output /tmp/carrier-frontier-review +``` + +`--write` rebuilds the committed scientific RESULT for authoring; the normal +command compares the complete deterministic payload. Both wrapper modes compile +scientific source with optimize=0. Local checkout modes must match the frozen +capsule manifest; a group-writable local umask may require restoring its declared +0644/0755 modes before the unchanged master can run. Hosted CI is separate from +local Linux replay. No Lean or actual Turing-tape execution is supplied. + +Local validation passed on Linux with CPython 3.12.13: the upstream metadata/pin +check and both registered ordinary/optimized replays, each including the complete +eight-engine baseline, all five changed applications and the rejection controls. +Ruff also passed for the three new Python files. The package preserves exact +source bytes across checkout filters; publication and Git-free export checks +are recorded separately in the PR handoff. + +## Open next questions + +1. Independently review the source-sensitive tuple application. Start with the + six changed conditions, complete paid-tail proof and generated proof diffs. + This matters because numerical success is not human or proof-kernel review; + none is claimed here. +2. Apply a different compiler geometry to this exact raw caller with a full + ordinary/precision bill. Smaller sufficient carriers still do not give a + practical runtime. A favorable raw moment alone does not supply that caller + or its convergence/implementation gates. + +## Credit + +Richard Hoekstra prepared this package with substantial OpenAI Codex assistance. +Chris R/Clear1nsight supplied the PR5413 caller audit, exact arithmetic and +precision/conjunction checks; Dillon Amburgey the provider; Ali Romman the direct +controller; Cao Yifan the native word; Cinna Davis the helper/product lineage; +zxv the compiler/precision/higher-moment machinery; Jacob Alan Sussman the mixed +flow. Retain the full cumulative source attribution and notices. New material +is Apache-2.0. No independent human or formal-kernel approval is claimed. diff --git a/research/pr5413-carrier-frontier/RESULT.json b/research/pr5413-carrier-frontier/RESULT.json new file mode 100644 index 0000000000..64840411aa --- /dev/null +++ b/research/pr5413-carrier-frontier/RESULT.json @@ -0,0 +1,1780 @@ +{ + "all_frozen_inputs_unchanged": true, + "cases": [ + { + "application_proof_sha256": "c9357d0afee043df807800006b20cbfa9e1fedf630cc864e9e4bf5b8e49f1677", + "case": "fixed-kappa", + "conjunction": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "premise_count": 25, + "premise_names": [ + "accepted_local_all649_and11controls", + "accepted_written_source_specialization", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "complete_paid_split_and_completion_bill", + "exact_frozen_v16c_B_F", + "exact_new_positive_endpoint_gap", + "fresh_alpha_both_tails_completion_eta", + "fresh_constructive_F16_semantic_stock_bound", + "fresh_height_and_preceding_height_grid", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ], + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION", + "unchanged_source_gate_names": [ + "accepted_local_all649_and11controls", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "exact_frozen_v16c_B_F", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ] + }, + "controls": { + "coarse_.97_envelope_is_actually_exceeded": true, + "free-completion_rejected_by_complete_rebuild": true, + "invalid_higher_moment_domain_rejected": true, + "missing-paid-job_rejected_by_complete_rebuild": true, + "original_conjunction_rejects_coarse_tail_application": true, + "original_precision_rejects_changed_carrier": true, + "preceding_grid_rejected": true, + "unfunded_product_domain_rejected": true + }, + "funding": { + "H": 12040700000000000, + "a": 7, + "actual_global_closure": false, + "alpha_upper": "6277101735354420171771431547781030093223132847876281747271/6277101735386680763835789423207666416102355444464034512896", + "case": "fixed-kappa", + "charging_model": "complete-higher-moment-sum-with-both-partial-block-tails", + "compiler_tuple_source_applicable": false, + "completion_slack": "32783443111987368366551706941483825379911374553703/6277101735386680763835789423207666416102355444464034512896", + "completion_tail_upper": "1815788453408946231332893596858669608869/3138550867693340381917894711603833208051177722232017256448", + "controls": {}, + "delta_upper": "6020810719608272987986436258331984969178281957506952529453/6277101735386680763835789423207666416102355444464034512896", + "economic_profile_gain": 0, + "eta_lower": "1988681851173212539113277639361127196843425285156047922642557375572811/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "fresh_precision_source_applicable": false, + "gain_over_comparison": "1/200000000000", + "gamma_upper": "1531974377643756080731149762526415542434411158082421503015/1569275433846670190958947355801916604025588861116008628224", + "gap": "1/700000000000", + "grid_scope": "First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.", + "grid_success": true, + "higher_tail_upper": "125701535720631938326156372745659259284036443261/3138550867693340381917894711603833208051177722232017256448", + "independent_outer_engine_sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47", + "invoice_sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450", + "j": 17201, + "kappa": "605457647/200000000000", + "model": "actual-routed-neutral-standard-p16", + "neutral_signed_identity": true, + "normalized_paid_upper": "6277101702603237651848421056655959474618530064552659959193/6277101735386680763835789423207666416102355444464034512896", + "ordinary_BIT": { + "actual": "8590884599/2500000000000", + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "stock_slack": "2481409115401/2500000000000" + }, + "ordinary_funded": false, + "original_paid_upper": "6277101702351834576775580273185754266461424352267247854933/6277101735386680763835789423207666416102355444464034512896", + "outer": { + "functional": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "593348495179152359293/196000000000000000000000", + "fused_gaussian": "593348495177457077879/196000000000000000000000", + "global_coordinate_router": "4238203537/1400000000000", + "group_bit_router": "2966742477287285389389/980000000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "593348494899152359293/196000000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "80218348495179152359293/196000000000000000000000" + }, + "minimum_functional": "3/700000000000", + "minimum_strict": "1/7000000000000", + "parameters": { + "a": "4238203537/1400000000000", + "b": "4238203539/1400000000000", + "beta": "699999999997/700000000000", + "bit_atom": "1/250", + "bit_saving": "17/5000", + "complex_uniform_saving": "4238203541/1400000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "605457647/200000000000", + "layout": "1/700000000000", + "q": "847640707/280000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "605457649/200000000000" + }, + "strict": { + "actual_bit_above_effective": "521796463/1400000000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "17781651505520847640707/98000000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "1119152359293/196000000000000000000000", + "cap_above_band": "80218348494899152359293/196000000000000000000000", + "cap_below_cell": "17781651504820847640707/196000000000000000000000", + "cap_below_phase_cell_power": "213781651505100847640707/196000000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "39511796461/1400000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "1117457077879/196000000000000000000000", + "gaussian_above_main": "139152359293/98000000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "6987285389389/980000000000000000000000", + "group_gauge_power_slack": "17781651505506847640707/98000000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "1395761796467/1400000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "648158907900418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "2795761796461/980000000000000000000000", + "leaf_saving_above_effective": "1395761796461/980000000000000000000000", + "main_transform_above_kappa": "839152359293/196000000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "107795761796479/1400000000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "1395761796469/1400000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "2795761796461/980000000000000000000000", + "q_positive": "847640707/280000000000", + "short_record_fallback": "1395761796461/1400000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "79625000001119152359293/196000000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "p": 16, + "paid": { + "1": 41154, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "possible_gain_type": "smaller carrier at unchanged or explicitly weaker exponent saving", + "preceding_grid_fails": true, + "predicates": { + "eta": true, + "exact_completed_moment": true, + "funded_alpha_reserve": true, + "height": true, + "higher_moment_domain": true, + "initial_range": true, + "ordered_savings": true, + "positive_partial_block_charges": true, + "raw_moment": true, + "shifted_exits": true, + "split": true, + "true_exit_exponent": true + }, + "raw_ceiling_changed": false, + "raw_tested_margin": [ + "12189257977815151351888891612502676384950860231657848294489/10000000000000000000000000000000000000000000000000000000000000000", + "30473144944537878379722229031256690962377150579144691710487/25000000000000000000000000000000000000000000000000000000000000000" + ], + "reserve": "1/1000000000000", + "reserve_slack": "6343625568596483071972786488284895061438088422982413449/1532495540865888858358347027150309183618739122183602176000000000000", + "scope": "Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.", + "source_predicates": { + "functional": [ + "actual_new_BIT_stock_sublinear", + "fixed_halo_explicit_metadata_branch", + "new_BIT_row_stock_sublinear_in_active_group", + "new_semantic_group_guard" + ], + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "strict": [ + "actual_bit_above_effective", + "actual_logarithmic_gamma_guard", + "actual_logarithmic_group_guard", + "alpha_logarithm_absorption", + "boundary_algebraic_matrix_above_kappa", + "cap_above_band", + "cap_below_cell", + "cap_below_phase_cell_power", + "complex_above_effective", + "complex_below_one_over_32", + "complex_endpoint", + "epsilon_below_one", + "epsilon_positive", + "fine_prime_halo_umbrella", + "fused_gaussian_above_kappa", + "gaussian_above_main", + "global_coordinate_router_above_kappa", + "global_gamma_power_slack", + "group_below_dimension", + "group_bit_router_above_kappa", + "group_gauge_power_slack", + "group_key_fits_record", + "group_positive", + "group_scans_above_kappa", + "halo_covers_generic_inverse_radius", + "improvement_over_user_baseline", + "lambda_above_internal", + "lambda_above_sigma", + "lambda_above_tau", + "lambda_prime_above_lambda", + "lambda_prime_above_leaf", + "leaf_saving_above_effective", + "main_transform_above_kappa", + "membership_arithmetic_fits_record", + "microbox_face_corrections_above_kappa", + "microbox_halo_volume", + "new_complex_uniform_saving_above_b", + "new_semantic_guard_with_C1_one", + "polynomial_products_above_kappa", + "positive_layout_slack", + "q_below_effective", + "q_below_internal", + "q_below_leaf", + "q_positive", + "short_record_fallback", + "source_axis_superpolynomial", + "sparse_union_movement_above_kappa", + "stop_below_one", + "stop_positive", + "strassen_integer_power_gap", + "support_router_span", + "theta_positive_polynomial_power", + "union_header_fits_record", + "union_tag_work_per_visit_fits_record" + ] + }, + "status": "PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY", + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 990, + "9": 5724 + }, + "tested": "605457649/200000000000", + "tuple": { + "ambient": 145, + "cutoff": 18, + "floor": 21, + "logarithm_power": 322, + "offset": "1/10", + "tensor_power": 1024, + "theta": "61/64" + }, + "whole_scientific_admission": false + }, + "precision": { + "carrier_H": 12040700000000000, + "carrier_gap": "1/700000000000", + "carrier_j": 17201, + "expanded": { + "A0": "2^128", + "D0": "2^1048576", + "M": "F16(2^12040700000000000)", + "N": "2^12040700000000000", + "actual_counts_bound": "W,P,U,O,R,G <= M", + "no_old_raw_or_expanded_caps_reused": true, + "precision": "Zbar=2M; Ebar=64*(4M+N+1)^3; Bbar=M+Ebar; C0bar=32*N*Bbar^2; C1=1", + "recursion": "F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)", + "stock": "[W*(O+1)]^Dord(d) times BIT stock and each additional independent live stock", + "strictified_log_upper": 585757 + }, + "status": "PASS_SCOPED_V16C_PRECISION_STOCK_AND_FRESH_RAW_MAJORANTS" + }, + "precision_baseline_conservativity": true, + "proof_substitution_sites": 7 + }, + { + "application_proof_sha256": "e8d0526109059e988d8478b7cb2035971bc70115614ef066ab083770b77e2268", + "case": "saving-003", + "conjunction": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "premise_count": 25, + "premise_names": [ + "accepted_local_all649_and11controls", + "accepted_written_source_specialization", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "complete_paid_split_and_completion_bill", + "exact_frozen_v16c_B_F", + "exact_new_positive_endpoint_gap", + "fresh_alpha_both_tails_completion_eta", + "fresh_constructive_F16_semantic_stock_bound", + "fresh_height_and_preceding_height_grid", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ], + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION", + "unchanged_source_gate_names": [ + "accepted_local_all649_and11controls", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "exact_frozen_v16c_B_F", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ] + }, + "controls": {}, + "funding": { + "H": 1239850102, + "a": 7, + "actual_global_closure": false, + "alpha_upper": "6277057180429237649007274531636667647248572848646388115963/6277101735386680763835789423207666416102355444464034512896", + "case": "saving-003", + "charging_model": "complete-higher-moment-sum-with-both-partial-block-tails", + "compiler_tuple_source_applicable": false, + "completion_slack": "21725214962713653239827082355377949644010886292493402127/6277101735386680763835789423207666416102355444464034512896", + "completion_tail_upper": "3679494894239590267045441532282112727511581848769/3138550867693340381917894711603833208051177722232017256448", + "controls": {}, + "delta_upper": "3010911417436732215333364860446736591732252319142293210513/3138550867693340381917894711603833208051177722232017256448", + "economic_profile_gain": 0, + "eta_lower": "9061637620988185577572541076726952451415632110692487580199528224966730961/20000000000000000000000000000000000000000000000000000000000000000000000000000", + "fresh_precision_source_applicable": false, + "gain_over_comparison": "-2728823/100000000000", + "gamma_upper": "6162991080846954065198722886419131890267524444916104019375/6277101735386680763835789423207666416102355444464034512896", + "gap": "16372947/5600000000000", + "grid_scope": "First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.", + "grid_success": true, + "higher_tail_upper": "522797489712943159355769333265050684021840998369474673/3138550867693340381917894711603833208051177722232017256448", + "independent_outer_engine_sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47", + "invoice_sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450", + "j": 3625, + "kappa": "3/1000", + "model": "actual-routed-neutral-standard-p16", + "neutral_signed_identity": true, + "normalized_paid_upper": "6255376520423967110595962340852288466458344558171541110769/6277101735386680763835789423207666416102355444464034512896", + "ordinary_BIT": { + "actual": "8590884599/2500000000000", + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "stock_slack": "2481409115401/2500000000000" + }, + "ordinary_funded": false, + "original_paid_upper": "6254330918085551435798070268094875300526075421151638463885/6277101735386680763835789423207666416102355444464034512896", + "outer": { + "functional": { + "actual_new_BIT_stock_sublinear": "1394387769408591/1400000000000000", + "fixed_halo_explicit_metadata_branch": "107800016372947/1400000000000", + "new_BIT_row_stock_sublinear_in_active_group": "5583151028515523/5600000000000000", + "new_semantic_group_guard": "49118841/5600000000000" + }, + "margins": { + "boundary_algebraic_matrix": "94446478143070219605573/31360000000000000000000000", + "fused_gaussian": "94445926403610658816719/31360000000000000000000000", + "global_coordinate_router": "4216372947/1400000000000", + "group_bit_router": "23634403525647619605573/7840000000000000000000000", + "group_scans": "2799983627053/2800000000000", + "main_transform": "94354789639870219605573/31360000000000000000000000", + "microbox_face_corrections": "107800016372947/1400000000000", + "polynomial_products": "5599983627053/5600000000000", + "sparse_union_movement": "12834446478143070219605573/31360000000000000000000000" + }, + "minimum_functional": "49118841/5600000000000", + "minimum_strict": "16372947/56000000000000", + "parameters": { + "a": "4216372947/1400000000000", + "b": "3376372947/1120000000000", + "beta": "5599950881159/5600000000000", + "bit_atom": "1/250", + "bit_saving": "17/5000", + "complex_uniform_saving": "8449118841/2800000000000", + "d": "16372947/5600000000000", + "epsilon": "5599983627053/5600000000000", + "kappa": "3/1000", + "layout": "16372947/5600000000000", + "q": "16849118841/5600000000000", + "r0": "16372947/56000000000000", + "stop": "16372947/5600000000000", + "tested_saving": "2416372947/800000000000" + }, + "strict": { + "actual_bit_above_effective": "543627053/1400000000000", + "actual_logarithmic_gamma_guard": "16372947/5600000000000", + "actual_logarithmic_group_guard": "2845782743114929780394427/15680000000000000000000000", + "alpha_logarithm_absorption": "16372947/56000000000000", + "boundary_algebraic_matrix_above_kappa": "366478143070219605573/31360000000000000000000000", + "cap_above_band": "12834354789639870219605573/31360000000000000000000000", + "cap_below_cell": "2845553521856929780394427/31360000000000000000000000", + "cap_below_phase_cell_power": "34205645210360129780394427/31360000000000000000000000", + "complex_above_effective": "16372947/5600000000000", + "complex_below_one_over_32": "31623627053/1120000000000", + "complex_endpoint": "16372947/2800000000000", + "epsilon_below_one": "16372947/5600000000000", + "epsilon_positive": "5599983627053/5600000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "365926403610658816719/31360000000000000000000000", + "gaussian_above_main": "45568381870219605573/15680000000000000000000000", + "global_coordinate_router_above_kappa": "16372947/1400000000000", + "global_gamma_power_slack": "147356523/56000000000000", + "group_below_dimension": "16372947/2800000000000", + "group_bit_router_above_kappa": "114403525647619605573/7840000000000000000000000", + "group_gauge_power_slack": "2845778158689769780394427/15680000000000000000000000", + "group_key_fits_record": "16372947/2800000000000", + "group_positive": "5599950881159/5600000000000", + "group_scans_above_kappa": "2791583627053/2800000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "634514790400418148631/500000000000000000000000", + "lambda_above_internal": "16372947/11200000000000", + "lambda_above_sigma": "49118841/11200000000000", + "lambda_above_tau": "16372947/11200000000000", + "lambda_prime_above_lambda": "16372947/11200000000000", + "lambda_prime_above_leaf": "36620120104686535191/6272000000000000000000000", + "leaf_saving_above_effective": "18282419464686535191/6272000000000000000000000", + "main_transform_above_kappa": "274789639870219605573/31360000000000000000000000", + "membership_arithmetic_fits_record": "16372947/5600000000000", + "microbox_face_corrections_above_kappa": "107795816372947/1400000000000", + "microbox_halo_volume": "442400049118841/5600000000000", + "new_complex_uniform_saving_above_b": "16372947/5600000000000", + "new_semantic_guard_with_C1_one": "16372947/5600000000000", + "polynomial_products_above_kappa": "5583183627053/5600000000000", + "positive_layout_slack": "16372947/5600000000000", + "q_below_effective": "16372947/5600000000000", + "q_below_internal": "16372947/5600000000000", + "q_below_leaf": "36620120104686535191/6272000000000000000000000", + "q_positive": "16849118841/5600000000000", + "short_record_fallback": "1116623627053/1120000000000", + "source_axis_superpolynomial": "16372947/5600000000000", + "sparse_union_movement_above_kappa": "12740366478143070219605573/31360000000000000000000000", + "stop_below_one": "5599983627053/5600000000000", + "stop_positive": "16372947/5600000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "49118841/5600000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "49118841/5600000000000", + "union_tag_work_per_visit_fits_record": "49118841/5600000000000" + } + }, + "p": 16, + "paid": { + "1": 41154, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "possible_gain_type": "smaller carrier at unchanged or explicitly weaker exponent saving", + "preceding_grid_fails": true, + "predicates": { + "eta": true, + "exact_completed_moment": true, + "funded_alpha_reserve": true, + "height": true, + "higher_moment_domain": true, + "initial_range": true, + "ordered_savings": true, + "positive_partial_block_charges": true, + "raw_moment": true, + "shifted_exits": true, + "split": true, + "true_exit_exponent": true + }, + "raw_ceiling_changed": false, + "raw_tested_margin": [ + "84174687945855143809193615504486183123440400048180911174561671901/50000000000000000000000000000000000000000000000000000000000000000", + "1315229499153986622018650242257596611303756250752826737104759331/781250000000000000000000000000000000000000000000000000000000000" + ], + "reserve": "1/1000000000000", + "reserve_slack": "10877673624514915314504591592524275042707373423838254037100949/1532495540865888858358347027150309183618739122183602176000000000000", + "scope": "Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.", + "source_predicates": { + "functional": [ + "actual_new_BIT_stock_sublinear", + "fixed_halo_explicit_metadata_branch", + "new_BIT_row_stock_sublinear_in_active_group", + "new_semantic_group_guard" + ], + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "strict": [ + "actual_bit_above_effective", + "actual_logarithmic_gamma_guard", + "actual_logarithmic_group_guard", + "alpha_logarithm_absorption", + "boundary_algebraic_matrix_above_kappa", + "cap_above_band", + "cap_below_cell", + "cap_below_phase_cell_power", + "complex_above_effective", + "complex_below_one_over_32", + "complex_endpoint", + "epsilon_below_one", + "epsilon_positive", + "fine_prime_halo_umbrella", + "fused_gaussian_above_kappa", + "gaussian_above_main", + "global_coordinate_router_above_kappa", + "global_gamma_power_slack", + "group_below_dimension", + "group_bit_router_above_kappa", + "group_gauge_power_slack", + "group_key_fits_record", + "group_positive", + "group_scans_above_kappa", + "halo_covers_generic_inverse_radius", + "improvement_over_user_baseline", + "lambda_above_internal", + "lambda_above_sigma", + "lambda_above_tau", + "lambda_prime_above_lambda", + "lambda_prime_above_leaf", + "leaf_saving_above_effective", + "main_transform_above_kappa", + "membership_arithmetic_fits_record", + "microbox_face_corrections_above_kappa", + "microbox_halo_volume", + "new_complex_uniform_saving_above_b", + "new_semantic_guard_with_C1_one", + "polynomial_products_above_kappa", + "positive_layout_slack", + "q_below_effective", + "q_below_internal", + "q_below_leaf", + "q_positive", + "short_record_fallback", + "source_axis_superpolynomial", + "sparse_union_movement_above_kappa", + "stop_below_one", + "stop_positive", + "strassen_integer_power_gap", + "support_router_span", + "theta_positive_polynomial_power", + "union_header_fits_record", + "union_tag_work_per_visit_fits_record" + ] + }, + "status": "PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY", + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 990, + "9": 5724 + }, + "tested": "2416372947/800000000000", + "tuple": { + "ambient": 145, + "cutoff": 17, + "floor": 21, + "logarithm_power": 120, + "offset": "1/10", + "tensor_power": 512, + "theta": "15/16" + }, + "whole_scientific_admission": false + }, + "precision": { + "carrier_H": 1239850102, + "carrier_gap": "16372947/5600000000000", + "carrier_j": 3625, + "expanded": { + "A0": "2^128", + "D0": "2^1048576", + "M": "F16(2^1239850102)", + "N": "2^1239850102", + "actual_counts_bound": "W,P,U,O,R,G <= M", + "no_old_raw_or_expanded_caps_reused": true, + "precision": "Zbar=2M; Ebar=64*(4M+N+1)^3; Bbar=M+Ebar; C0bar=32*N*Bbar^2; C1=1", + "recursion": "F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)", + "stock": "[W*(O+1)]^Dord(d) times BIT stock and each additional independent live stock", + "strictified_log_upper": 292893 + }, + "status": "PASS_SCOPED_V16C_PRECISION_STOCK_AND_FRESH_RAW_MAJORANTS" + }, + "precision_baseline_conservativity": null, + "proof_substitution_sites": 7 + }, + { + "application_proof_sha256": "f640d3d97840ba2abb77cdafcf7e5b4b152e6b08464bb182450a823d1d0a69d3", + "case": "saving-00275", + "conjunction": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "premise_count": 25, + "premise_names": [ + "accepted_local_all649_and11controls", + "accepted_written_source_specialization", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "complete_paid_split_and_completion_bill", + "exact_frozen_v16c_B_F", + "exact_new_positive_endpoint_gap", + "fresh_alpha_both_tails_completion_eta", + "fresh_constructive_F16_semantic_stock_bound", + "fresh_height_and_preceding_height_grid", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ], + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION", + "unchanged_source_gate_names": [ + "accepted_local_all649_and11controls", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "exact_frozen_v16c_B_F", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ] + }, + "controls": {}, + "funding": { + "H": 50859231, + "a": 7, + "actual_global_closure": false, + "alpha_upper": "1569162257853342770810663211849157927478150905588665218223/1569275433846670190958947355801916604025588861116008628224", + "case": "saving-00275", + "charging_model": "complete-higher-moment-sum-with-both-partial-block-tails", + "compiler_tuple_source_applicable": false, + "completion_slack": "1382806236225109140326040994730941797480781841030429737/6277101735386680763835789423207666416102355444464034512896", + "completion_tail_upper": "18777827506222939848531260374483221463935748827956035/392318858461667547739736838950479151006397215279002157056", + "controls": {}, + "delta_upper": "6021549948082000182298637623467581996293662090714352177155/6277101735386680763835789423207666416102355444464034512896", + "economic_profile_gain": 0, + "eta_lower": "1841325505082445327388445687295405024150358617046474234178569601791394307931/80000000000000000000000000000000000000000000000000000000000000000000000000000", + "fresh_precision_source_applicable": false, + "gain_over_comparison": "-27728823/100000000000", + "gamma_upper": "770336312185209258921385771462657534247354183283909255833/784637716923335095479473677900958302012794430558004314112", + "gap": "166372947/5600000000000", + "grid_scope": "First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.", + "grid_success": true, + "higher_tail_upper": "56574890464258312601210364678272141196805739481281573643/3138550867693340381917894711603833208051177722232017256448", + "independent_outer_engine_sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47", + "invoice_sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450", + "j": 1511, + "kappa": "11/4000", + "model": "actual-routed-neutral-standard-p16", + "neutral_signed_identity": true, + "normalized_paid_upper": "6275718929150455654695463382212935474304874662623004083159/6277101735386680763835789423207666416102355444464034512896", + "ordinary_BIT": { + "actual": "8590884599/2500000000000", + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "stock_slack": "2481409115401/2500000000000" + }, + "ordinary_funded": false, + "original_paid_upper": "6162268702981839462455466152690399460367840211679193639313/6277101735386680763835789423207666416102355444464034512896", + "outer": { + "functional": { + "actual_new_BIT_stock_sublinear": "1394275719408591/1400000000000000", + "fixed_halo_explicit_metadata_branch": "107800166372947/1400000000000", + "new_BIT_row_stock_sublinear_in_active_group": "5582702378515523/5600000000000000", + "new_semantic_group_guard": "499118841/5600000000000" + }, + "margins": { + "boundary_algebraic_matrix": "89964108829543719605573/31360000000000000000000000", + "fused_gaussian": "89958818463031158816719/31360000000000000000000000", + "global_coordinate_router": "4016372947/1400000000000", + "group_bit_router": "22722605981589669605573/7840000000000000000000000", + "group_scans": "2799833627053/2800000000000", + "main_transform": "89032420326343719605573/31360000000000000000000000", + "microbox_face_corrections": "107800166372947/1400000000000", + "polynomial_products": "5599833627053/5600000000000", + "sparse_union_movement": "12829964108829543719605573/31360000000000000000000000" + }, + "minimum_functional": "499118841/5600000000000", + "minimum_strict": "166372947/56000000000000", + "parameters": { + "a": "4016372947/1400000000000", + "b": "3246372947/1120000000000", + "beta": "5599500881159/5600000000000", + "bit_atom": "1/250", + "bit_saving": "17/5000", + "complex_uniform_saving": "8199118841/2800000000000", + "d": "166372947/5600000000000", + "epsilon": "5599833627053/5600000000000", + "kappa": "11/4000", + "layout": "166372947/5600000000000", + "q": "15899118841/5600000000000", + "r0": "166372947/56000000000000", + "stop": "166372947/5600000000000", + "tested_saving": "2366372947/800000000000" + }, + "strict": { + "actual_bit_above_effective": "743627053/1400000000000", + "actual_logarithmic_gamma_guard": "166372947/5600000000000", + "actual_logarithmic_group_guard": "2852365112428456280394427/15680000000000000000000000", + "alpha_logarithm_absorption": "166372947/56000000000000", + "boundary_algebraic_matrix_above_kappa": "3724108829543719605573/31360000000000000000000000", + "cap_above_band": "12829032420326343719605573/31360000000000000000000000", + "cap_below_cell": "2850035891170456280394427/31360000000000000000000000", + "cap_below_phase_cell_power": "34210967579673656280394427/31360000000000000000000000", + "complex_above_effective": "166372947/5600000000000", + "complex_below_one_over_32": "31753627053/1120000000000", + "complex_endpoint": "166372947/2800000000000", + "epsilon_below_one": "166372947/5600000000000", + "epsilon_positive": "5599833627053/5600000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "3718818463031158816719/31360000000000000000000000", + "gaussian_above_main": "463199068343719605573/15680000000000000000000000", + "global_coordinate_router_above_kappa": "166372947/1400000000000", + "global_gamma_power_slack": "1497356523/56000000000000", + "group_below_dimension": "166372947/2800000000000", + "group_bit_router_above_kappa": "1162605981589669605573/7840000000000000000000000", + "group_gauge_power_slack": "2852318528003296280394427/15680000000000000000000000", + "group_key_fits_record": "166372947/2800000000000", + "group_positive": "5599500881159/5600000000000", + "group_scans_above_kappa": "2792133627053/2800000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "509514790400418148631/500000000000000000000000", + "lambda_above_internal": "166372947/11200000000000", + "lambda_above_sigma": "499118841/11200000000000", + "lambda_above_tau": "166372947/11200000000000", + "lambda_prime_above_lambda": "166372947/11200000000000", + "lambda_prime_above_leaf": "372135292645746535191/6272000000000000000000000", + "leaf_saving_above_effective": "185797592005746535191/6272000000000000000000000", + "main_transform_above_kappa": "2792420326343719605573/31360000000000000000000000", + "membership_arithmetic_fits_record": "166372947/5600000000000", + "microbox_face_corrections_above_kappa": "107796316372947/1400000000000", + "microbox_halo_volume": "442400499118841/5600000000000", + "new_complex_uniform_saving_above_b": "166372947/5600000000000", + "new_semantic_guard_with_C1_one": "166372947/5600000000000", + "polynomial_products_above_kappa": "5584433627053/5600000000000", + "positive_layout_slack": "166372947/5600000000000", + "q_below_effective": "166372947/5600000000000", + "q_below_internal": "166372947/5600000000000", + "q_below_leaf": "372135292645746535191/6272000000000000000000000", + "q_positive": "15899118841/5600000000000", + "short_record_fallback": "1116753627053/1120000000000", + "source_axis_superpolynomial": "166372947/5600000000000", + "sparse_union_movement_above_kappa": "12743724108829543719605573/31360000000000000000000000", + "stop_below_one": "5599833627053/5600000000000", + "stop_positive": "166372947/5600000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "499118841/5600000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "499118841/5600000000000", + "union_tag_work_per_visit_fits_record": "499118841/5600000000000" + } + }, + "p": 16, + "paid": { + "1": 41154, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "possible_gain_type": "smaller carrier at unchanged or explicitly weaker exponent saving", + "preceding_grid_fails": true, + "predicates": { + "eta": true, + "exact_completed_moment": true, + "funded_alpha_reserve": true, + "height": true, + "higher_moment_domain": true, + "initial_range": true, + "ordered_savings": true, + "positive_partial_block_charges": true, + "raw_moment": true, + "shifted_exits": true, + "split": true, + "true_exit_exponent": true + }, + "raw_ceiling_changed": false, + "raw_tested_margin": [ + "34218137219327050669455610409020609519206362945312946570979793603/2000000000000000000000000000000000000000000000000000000000000000", + "427726715241588133368195130112757618990079536816411832137317355227/25000000000000000000000000000000000000000000000000000000000000000" + ], + "reserve": "1/1000000000000", + "reserve_slack": "27630857362828299423211367626887009676767315263139926729490081/383123885216472214589586756787577295904684780545900544000000000000", + "scope": "Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.", + "source_predicates": { + "functional": [ + "actual_new_BIT_stock_sublinear", + "fixed_halo_explicit_metadata_branch", + "new_BIT_row_stock_sublinear_in_active_group", + "new_semantic_group_guard" + ], + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "strict": [ + "actual_bit_above_effective", + "actual_logarithmic_gamma_guard", + "actual_logarithmic_group_guard", + "alpha_logarithm_absorption", + "boundary_algebraic_matrix_above_kappa", + "cap_above_band", + "cap_below_cell", + "cap_below_phase_cell_power", + "complex_above_effective", + "complex_below_one_over_32", + "complex_endpoint", + "epsilon_below_one", + "epsilon_positive", + "fine_prime_halo_umbrella", + "fused_gaussian_above_kappa", + "gaussian_above_main", + "global_coordinate_router_above_kappa", + "global_gamma_power_slack", + "group_below_dimension", + "group_bit_router_above_kappa", + "group_gauge_power_slack", + "group_key_fits_record", + "group_positive", + "group_scans_above_kappa", + "halo_covers_generic_inverse_radius", + "improvement_over_user_baseline", + "lambda_above_internal", + "lambda_above_sigma", + "lambda_above_tau", + "lambda_prime_above_lambda", + "lambda_prime_above_leaf", + "leaf_saving_above_effective", + "main_transform_above_kappa", + "membership_arithmetic_fits_record", + "microbox_face_corrections_above_kappa", + "microbox_halo_volume", + "new_complex_uniform_saving_above_b", + "new_semantic_guard_with_C1_one", + "polynomial_products_above_kappa", + "positive_layout_slack", + "q_below_effective", + "q_below_internal", + "q_below_leaf", + "q_positive", + "short_record_fallback", + "source_axis_superpolynomial", + "sparse_union_movement_above_kappa", + "stop_below_one", + "stop_positive", + "strassen_integer_power_gap", + "support_router_span", + "theta_positive_polynomial_power", + "union_header_fits_record", + "union_tag_work_per_visit_fits_record" + ] + }, + "status": "PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY", + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 990, + "9": 5724 + }, + "tested": "2366372947/800000000000", + "tuple": { + "ambient": 145, + "cutoff": 17, + "floor": 21, + "logarithm_power": 59, + "offset": "1/10", + "tensor_power": 256, + "theta": "15/16" + }, + "whole_scientific_admission": false + }, + "precision": { + "carrier_H": 50859231, + "carrier_gap": "166372947/5600000000000", + "carrier_j": 1511, + "expanded": { + "A0": "2^128", + "D0": "2^1048576", + "M": "F16(2^50859231)", + "N": "2^50859231", + "actual_counts_bound": "W,P,U,O,R,G <= M", + "no_old_raw_or_expanded_caps_reused": true, + "precision": "Zbar=2M; Ebar=64*(4M+N+1)^3; Bbar=M+Ebar; C0bar=32*N*Bbar^2; C1=1", + "recursion": "F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)", + "stock": "[W*(O+1)]^Dord(d) times BIT stock and each additional independent live stock", + "strictified_log_upper": 146461 + }, + "status": "PASS_SCOPED_V16C_PRECISION_STOCK_AND_FRESH_RAW_MAJORANTS" + }, + "precision_baseline_conservativity": null, + "proof_substitution_sites": 7 + }, + { + "application_proof_sha256": "7acaefa77d5afb50df4fc91748cea877f1eefe2fc7e302b82182a9021311568e", + "case": "saving-0025", + "conjunction": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "premise_count": 25, + "premise_names": [ + "accepted_local_all649_and11controls", + "accepted_written_source_specialization", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "complete_paid_split_and_completion_bill", + "exact_frozen_v16c_B_F", + "exact_new_positive_endpoint_gap", + "fresh_alpha_both_tails_completion_eta", + "fresh_constructive_F16_semantic_stock_bound", + "fresh_height_and_preceding_height_grid", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ], + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION", + "unchanged_source_gate_names": [ + "accepted_local_all649_and11controls", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "exact_frozen_v16c_B_F", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ] + }, + "controls": {}, + "funding": { + "H": 25258797, + "a": 7, + "actual_global_closure": false, + "alpha_upper": "392265059530957614021677356223106187425421277685454501211/392318858461667547739736838950479151006397215279002157056", + "case": "saving-0025", + "charging_model": "complete-higher-moment-sum-with-both-partial-block-tails", + "compiler_tuple_source_applicable": false, + "completion_slack": "26127256569281167654246096156953113282221919036515085927/1569275433846670190958947355801916604025588861116008628224", + "completion_tail_upper": "296979565887922002642706421835752370061509963087793689/6277101735386680763835789423207666416102355444464034512896", + "controls": {}, + "delta_upper": "6021277051662634214339537898093958161774095556600660196377/6277101735386680763835789423207666416102355444464034512896", + "economic_profile_gain": 0, + "eta_lower": "398813338991255597865577726275761786524758726227704287590525756461949154051/16000000000000000000000000000000000000000000000000000000000000000000000000000", + "fresh_precision_source_applicable": false, + "gain_over_comparison": "-52728823/100000000000", + "gamma_upper": "1540597491448138857366042563770987041971539318182012744491/1569275433846670190958947355801916604025588861116008628224", + "gap": "316372947/5600000000000", + "grid_scope": "First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.", + "grid_success": true, + "higher_tail_upper": "111745946020232524808287740857456153633462684261364715731/6277101735386680763835789423207666416102355444464034512896", + "independent_outer_engine_sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47", + "invoice_sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450", + "j": 1427, + "kappa": "1/400", + "model": "actual-routed-neutral-standard-p16", + "neutral_signed_identity": true, + "normalized_paid_upper": "1543148177277389023304701259644963490743366942079493542297/1569275433846670190958947355801916604025588861116008628224", + "ordinary_BIT": { + "actual": "8590884599/2500000000000", + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "stock_slack": "2481409115401/2500000000000" + }, + "ordinary_funded": false, + "original_paid_upper": "757568722940429455800984323912570257121242946761690207471/784637716923335095479473677900958302012794430558004314112", + "outer": { + "functional": { + "actual_new_BIT_stock_sublinear": "1394163669408591/1400000000000000", + "fixed_halo_explicit_metadata_branch": "107800316372947/1400000000000", + "new_BIT_row_stock_sublinear_in_active_group": "5582253728515523/5600000000000000", + "new_semantic_group_guard": "949118841/5600000000000" + }, + "margins": { + "boundary_algebraic_matrix": "85482024516017219605573/31360000000000000000000000", + "fused_gaussian": "85472565522451658816719/31360000000000000000000000", + "global_coordinate_router": "3816372947/1400000000000", + "group_bit_router": "21810988437531719605573/7840000000000000000000000", + "group_scans": "2799683627053/2800000000000", + "main_transform": "83710336012817219605573/31360000000000000000000000", + "microbox_face_corrections": "107800316372947/1400000000000", + "polynomial_products": "5599683627053/5600000000000", + "sparse_union_movement": "12825482024516017219605573/31360000000000000000000000" + }, + "minimum_functional": "949118841/5600000000000", + "minimum_strict": "316372947/56000000000000", + "parameters": { + "a": "3816372947/1400000000000", + "b": "3116372947/1120000000000", + "beta": "5599050881159/5600000000000", + "bit_atom": "1/250", + "bit_saving": "17/5000", + "complex_uniform_saving": "7949118841/2800000000000", + "d": "316372947/5600000000000", + "epsilon": "5599683627053/5600000000000", + "kappa": "1/400", + "layout": "316372947/5600000000000", + "q": "14949118841/5600000000000", + "r0": "316372947/56000000000000", + "stop": "316372947/5600000000000", + "tested_saving": "2316372947/800000000000" + }, + "strict": { + "actual_bit_above_effective": "943627053/1400000000000", + "actual_logarithmic_gamma_guard": "316372947/5600000000000", + "actual_logarithmic_group_guard": "2858947196741982780394427/15680000000000000000000000", + "alpha_logarithm_absorption": "316372947/56000000000000", + "boundary_algebraic_matrix_above_kappa": "7082024516017219605573/31360000000000000000000000", + "cap_above_band": "12823710336012817219605573/31360000000000000000000000", + "cap_below_cell": "2854517975483982780394427/31360000000000000000000000", + "cap_below_phase_cell_power": "34216289663987182780394427/31360000000000000000000000", + "complex_above_effective": "316372947/5600000000000", + "complex_below_one_over_32": "31883627053/1120000000000", + "complex_endpoint": "316372947/2800000000000", + "epsilon_below_one": "316372947/5600000000000", + "epsilon_positive": "5599683627053/5600000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "7072565522451658816719/31360000000000000000000000", + "gaussian_above_main": "881114754817219605573/15680000000000000000000000", + "global_coordinate_router_above_kappa": "316372947/1400000000000", + "global_gamma_power_slack": "2847356523/56000000000000", + "group_below_dimension": "316372947/2800000000000", + "group_bit_router_above_kappa": "2210988437531719605573/7840000000000000000000000", + "group_gauge_power_slack": "2858858612316822780394427/15680000000000000000000000", + "group_key_fits_record": "316372947/2800000000000", + "group_positive": "5599050881159/5600000000000", + "group_scans_above_kappa": "2792683627053/2800000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "384514790400418148631/500000000000000000000000", + "lambda_above_internal": "316372947/11200000000000", + "lambda_above_sigma": "949118841/11200000000000", + "lambda_above_tau": "316372947/11200000000000", + "lambda_prime_above_lambda": "316372947/11200000000000", + "lambda_prime_above_leaf": "707689465186806535191/6272000000000000000000000", + "leaf_saving_above_effective": "353351764546806535191/6272000000000000000000000", + "main_transform_above_kappa": "5310336012817219605573/31360000000000000000000000", + "membership_arithmetic_fits_record": "316372947/5600000000000", + "microbox_face_corrections_above_kappa": "107796816372947/1400000000000", + "microbox_halo_volume": "442400949118841/5600000000000", + "new_complex_uniform_saving_above_b": "316372947/5600000000000", + "new_semantic_guard_with_C1_one": "316372947/5600000000000", + "polynomial_products_above_kappa": "5585683627053/5600000000000", + "positive_layout_slack": "316372947/5600000000000", + "q_below_effective": "316372947/5600000000000", + "q_below_internal": "316372947/5600000000000", + "q_below_leaf": "707689465186806535191/6272000000000000000000000", + "q_positive": "14949118841/5600000000000", + "short_record_fallback": "1116883627053/1120000000000", + "source_axis_superpolynomial": "316372947/5600000000000", + "sparse_union_movement_above_kappa": "12747082024516017219605573/31360000000000000000000000", + "stop_below_one": "5599683627053/5600000000000", + "stop_positive": "316372947/5600000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "949118841/5600000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "949118841/5600000000000", + "union_tag_work_per_visit_fits_record": "949118841/5600000000000" + } + }, + "p": 16, + "paid": { + "1": 41154, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "possible_gain_type": "smaller carrier at unchanged or explicitly weaker exponent saving", + "preceding_grid_fails": true, + "predicates": { + "eta": true, + "exact_completed_moment": true, + "funded_alpha_reserve": true, + "height": true, + "higher_moment_domain": true, + "initial_range": true, + "ordered_savings": true, + "positive_partial_block_charges": true, + "raw_moment": true, + "shifted_exits": true, + "split": true, + "true_exit_exponent": true + }, + "raw_ceiling_changed": false, + "raw_tested_margin": [ + "1626942777185247435458225504537018786139776300041903390356070005599/50000000000000000000000000000000000000000000000000000000000000000", + "50841961787038982358069547016781837066868009376309480948631554021/1562500000000000000000000000000000000000000000000000000000000000" + ], + "reserve": "1/1000000000000", + "reserve_slack": "13134504472073940331497846590143247564809190073549470146727989/95780971304118053647396689196894323976171195136475136000000000000", + "scope": "Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.", + "source_predicates": { + "functional": [ + "actual_new_BIT_stock_sublinear", + "fixed_halo_explicit_metadata_branch", + "new_BIT_row_stock_sublinear_in_active_group", + "new_semantic_group_guard" + ], + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "strict": [ + "actual_bit_above_effective", + "actual_logarithmic_gamma_guard", + "actual_logarithmic_group_guard", + "alpha_logarithm_absorption", + "boundary_algebraic_matrix_above_kappa", + "cap_above_band", + "cap_below_cell", + "cap_below_phase_cell_power", + "complex_above_effective", + "complex_below_one_over_32", + "complex_endpoint", + "epsilon_below_one", + "epsilon_positive", + "fine_prime_halo_umbrella", + "fused_gaussian_above_kappa", + "gaussian_above_main", + "global_coordinate_router_above_kappa", + "global_gamma_power_slack", + "group_below_dimension", + "group_bit_router_above_kappa", + "group_gauge_power_slack", + "group_key_fits_record", + "group_positive", + "group_scans_above_kappa", + "halo_covers_generic_inverse_radius", + "improvement_over_user_baseline", + "lambda_above_internal", + "lambda_above_sigma", + "lambda_above_tau", + "lambda_prime_above_lambda", + "lambda_prime_above_leaf", + "leaf_saving_above_effective", + "main_transform_above_kappa", + "membership_arithmetic_fits_record", + "microbox_face_corrections_above_kappa", + "microbox_halo_volume", + "new_complex_uniform_saving_above_b", + "new_semantic_guard_with_C1_one", + "polynomial_products_above_kappa", + "positive_layout_slack", + "q_below_effective", + "q_below_internal", + "q_below_leaf", + "q_positive", + "short_record_fallback", + "source_axis_superpolynomial", + "sparse_union_movement_above_kappa", + "stop_below_one", + "stop_positive", + "strassen_integer_power_gap", + "support_router_span", + "theta_positive_polynomial_power", + "union_header_fits_record", + "union_tag_work_per_visit_fits_record" + ] + }, + "status": "PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY", + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 990, + "9": 5724 + }, + "tested": "2316372947/800000000000", + "tuple": { + "ambient": 145, + "cutoff": 17, + "floor": 21, + "logarithm_power": 58, + "offset": "1/10", + "tensor_power": 256, + "theta": "15/16" + }, + "whole_scientific_admission": false + }, + "precision": { + "carrier_H": 25258797, + "carrier_gap": "316372947/5600000000000", + "carrier_j": 1427, + "expanded": { + "A0": "2^128", + "D0": "2^1048576", + "M": "F16(2^25258797)", + "N": "2^25258797", + "actual_counts_bound": "W,P,U,O,R,G <= M", + "no_old_raw_or_expanded_caps_reused": true, + "precision": "Zbar=2M; Ebar=64*(4M+N+1)^3; Bbar=M+Ebar; C0bar=32*N*Bbar^2; C1=1", + "recursion": "F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)", + "stock": "[W*(O+1)]^Dord(d) times BIT stock and each additional independent live stock", + "strictified_log_upper": 146461 + }, + "status": "PASS_SCOPED_V16C_PRECISION_STOCK_AND_FRESH_RAW_MAJORANTS" + }, + "precision_baseline_conservativity": null, + "proof_substitution_sites": 7 + }, + { + "application_proof_sha256": "e2f9ee9f9d4ed7e999aedbf54030ac34c458144ecdee868a563686df7667f80d", + "case": "saving-002", + "conjunction": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "premise_count": 25, + "premise_names": [ + "accepted_local_all649_and11controls", + "accepted_written_source_specialization", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "complete_paid_split_and_completion_bill", + "exact_frozen_v16c_B_F", + "exact_new_positive_endpoint_gap", + "fresh_alpha_both_tails_completion_eta", + "fresh_constructive_F16_semantic_stock_bound", + "fresh_height_and_preceding_height_grid", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ], + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION", + "unchanged_source_gate_names": [ + "accepted_local_all649_and11controls", + "actual_global_integer_ID_join", + "actual_paid_C8_and_new_positive_C8_routes", + "actual_preRIGHT_events_LEFT_post_order", + "all18_B_old_controller_exact", + "all30368_canonical_layout_maps", + "all54_strict_and4_functional_outer_rows", + "all_four_complete_profiles_identical", + "exact_frozen_v16c_B_F", + "fresh_ordinary_physical_majorants_not_old_caps", + "narrow_component_false_flags_preserved", + "ordinary_BIT_and_product_stock_spare_power", + "owned418_and_distinct7344_helpers", + "precision_and_join_use_exact_final_B_F_plan", + "precision_v3_exact_same_carrier_and_sources", + "reused_provider_exact_actual_bytes", + "same_accepted400_forward_aliases", + "whole_main_Laurent_and_eight_controls", + "zero_economic_gain_exact_neutral_profile" + ] + }, + "controls": {}, + "funding": { + "H": 11738348, + "a": 7, + "actual_global_closure": false, + "alpha_upper": "6275425004902114395051248318631523124490254424672654915725/6277101735386680763835789423207666416102355444464034512896", + "case": "saving-002", + "charging_model": "complete-higher-moment-sum-with-both-partial-block-tails", + "compiler_tuple_source_applicable": false, + "completion_slack": "305668140377450853494077881717213722350824993346393308597/6277101735386680763835789423207666416102355444464034512896", + "completion_tail_upper": "72541718331273408264985351296455163327149321417896009/1569275433846670190958947355801916604025588861116008628224", + "controls": {}, + "delta_upper": "6020731229951749670458887172271702509079005761524883831205/6277101735386680763835789423207666416102355444464034512896", + "economic_profile_gain": 0, + "eta_lower": "146163156850234939271190540705298951358226845002631480670641933318519267089/5000000000000000000000000000000000000000000000000000000000000000000000000000", + "fresh_precision_source_applicable": false, + "gain_over_comparison": "-102728823/100000000000", + "gamma_upper": "3080894528701596479427638682376642343157421213348408883787/3138550867693340381917894711603833208051177722232017256448", + "gap": "616372947/5600000000000", + "grid_scope": "First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.", + "grid_success": true, + "higher_tail_upper": "6811925902449476007353477858638603942151630710393469435/392318858461667547739736838950479151006397215279002157056", + "independent_outer_engine_sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47", + "invoice_sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450", + "j": 1292, + "kappa": "1/500", + "model": "actual-routed-neutral-standard-p16", + "neutral_signed_identity": true, + "normalized_paid_upper": "5971433595009229910341711541490452693751530451117641204299/6277101735386680763835789423207666416102355444464034512896", + "ordinary_BIT": { + "actual": "8590884599/2500000000000", + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "stock_slack": "2481409115401/2500000000000" + }, + "ordinary_funded": false, + "original_paid_upper": "5862152613696713200590995954347049210023795762465674109303/6277101735386680763835789423207666416102355444464034512896", + "outer": { + "functional": { + "actual_new_BIT_stock_sublinear": "1393939569408591/1400000000000000", + "fixed_halo_explicit_metadata_branch": "107800616372947/1400000000000", + "new_BIT_row_stock_sublinear_in_active_group": "5581356428515523/5600000000000000", + "new_semantic_group_guard": "1849118841/5600000000000" + }, + "margins": { + "boundary_algebraic_matrix": "76518710888964219605573/31360000000000000000000000", + "fused_gaussian": "76502624641292658816719/31360000000000000000000000", + "global_coordinate_router": "3416372947/1400000000000", + "group_bit_router": "19988293349415819605573/7840000000000000000000000", + "group_scans": "2799383627053/2800000000000", + "main_transform": "73067022385764219605573/31360000000000000000000000", + "microbox_face_corrections": "107800616372947/1400000000000", + "polynomial_products": "5599383627053/5600000000000", + "sparse_union_movement": "12816518710888964219605573/31360000000000000000000000" + }, + "minimum_functional": "1849118841/5600000000000", + "minimum_strict": "616372947/56000000000000", + "parameters": { + "a": "3416372947/1400000000000", + "b": "2856372947/1120000000000", + "beta": "5598150881159/5600000000000", + "bit_atom": "1/250", + "bit_saving": "17/5000", + "complex_uniform_saving": "7449118841/2800000000000", + "d": "616372947/5600000000000", + "epsilon": "5599383627053/5600000000000", + "kappa": "1/500", + "layout": "616372947/5600000000000", + "q": "13049118841/5600000000000", + "r0": "616372947/56000000000000", + "stop": "616372947/5600000000000", + "tested_saving": "2216372947/800000000000" + }, + "strict": { + "actual_bit_above_effective": "1343627053/1400000000000", + "actual_logarithmic_gamma_guard": "616372947/5600000000000", + "actual_logarithmic_group_guard": "2872110510369035780394427/15680000000000000000000000", + "alpha_logarithm_absorption": "616372947/56000000000000", + "boundary_algebraic_matrix_above_kappa": "13798710888964219605573/31360000000000000000000000", + "cap_above_band": "12813067022385764219605573/31360000000000000000000000", + "cap_below_cell": "2863481289111035780394427/31360000000000000000000000", + "cap_below_phase_cell_power": "34226932977614235780394427/31360000000000000000000000", + "complex_above_effective": "616372947/5600000000000", + "complex_below_one_over_32": "32143627053/1120000000000", + "complex_endpoint": "616372947/2800000000000", + "epsilon_below_one": "616372947/5600000000000", + "epsilon_positive": "5599383627053/5600000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "13782624641292658816719/31360000000000000000000000", + "gaussian_above_main": "1717801127764219605573/15680000000000000000000000", + "global_coordinate_router_above_kappa": "616372947/1400000000000", + "global_gamma_power_slack": "5547356523/56000000000000", + "group_below_dimension": "616372947/2800000000000", + "group_bit_router_above_kappa": "4308293349415819605573/7840000000000000000000000", + "group_gauge_power_slack": "2871937925943875780394427/15680000000000000000000000", + "group_key_fits_record": "616372947/2800000000000", + "group_positive": "5598150881159/5600000000000", + "group_scans_above_kappa": "2793783627053/2800000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "134514790400418148631/500000000000000000000000", + "lambda_above_internal": "616372947/11200000000000", + "lambda_above_sigma": "1849118841/11200000000000", + "lambda_above_tau": "616372947/11200000000000", + "lambda_prime_above_lambda": "616372947/11200000000000", + "lambda_prime_above_leaf": "1378914810268926535191/6272000000000000000000000", + "leaf_saving_above_effective": "688577109628926535191/6272000000000000000000000", + "main_transform_above_kappa": "10347022385764219605573/31360000000000000000000000", + "membership_arithmetic_fits_record": "616372947/5600000000000", + "microbox_face_corrections_above_kappa": "107797816372947/1400000000000", + "microbox_halo_volume": "442401849118841/5600000000000", + "new_complex_uniform_saving_above_b": "616372947/5600000000000", + "new_semantic_guard_with_C1_one": "616372947/5600000000000", + "polynomial_products_above_kappa": "5588183627053/5600000000000", + "positive_layout_slack": "616372947/5600000000000", + "q_below_effective": "616372947/5600000000000", + "q_below_internal": "616372947/5600000000000", + "q_below_leaf": "1378914810268926535191/6272000000000000000000000", + "q_positive": "13049118841/5600000000000", + "short_record_fallback": "1117143627053/1120000000000", + "source_axis_superpolynomial": "616372947/5600000000000", + "sparse_union_movement_above_kappa": "12753798710888964219605573/31360000000000000000000000", + "stop_below_one": "5599383627053/5600000000000", + "stop_positive": "616372947/5600000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "1849118841/5600000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "1849118841/5600000000000", + "union_tag_work_per_visit_fits_record": "1849118841/5600000000000" + } + }, + "p": 16, + "paid": { + "1": 41154, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "possible_gain_type": "smaller carrier at unchanged or explicitly weaker exponent saving", + "preceding_grid_fails": true, + "predicates": { + "eta": true, + "exact_completed_moment": true, + "funded_alpha_reserve": true, + "height": true, + "higher_moment_domain": true, + "initial_range": true, + "ordered_savings": true, + "positive_partial_block_charges": true, + "raw_moment": true, + "shifted_exits": true, + "split": true, + "true_exit_exponent": true + }, + "raw_ceiling_changed": false, + "raw_tested_margin": [ + "126822140669920635457991720169239648303121119309167831587981935249/2000000000000000000000000000000000000000000000000000000000000000", + "99079797398375496451556031382218475236813374460287368428115272579/1562500000000000000000000000000000000000000000000000000000000000" + ], + "reserve": "1/1000000000000", + "reserve_slack": "409358026926090588172466751051636276585291351386045343392569699/1532495540865888858358347027150309183618739122183602176000000000000", + "scope": "Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.", + "source_predicates": { + "functional": [ + "actual_new_BIT_stock_sublinear", + "fixed_halo_explicit_metadata_branch", + "new_BIT_row_stock_sublinear_in_active_group", + "new_semantic_group_guard" + ], + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "strict": [ + "actual_bit_above_effective", + "actual_logarithmic_gamma_guard", + "actual_logarithmic_group_guard", + "alpha_logarithm_absorption", + "boundary_algebraic_matrix_above_kappa", + "cap_above_band", + "cap_below_cell", + "cap_below_phase_cell_power", + "complex_above_effective", + "complex_below_one_over_32", + "complex_endpoint", + "epsilon_below_one", + "epsilon_positive", + "fine_prime_halo_umbrella", + "fused_gaussian_above_kappa", + "gaussian_above_main", + "global_coordinate_router_above_kappa", + "global_gamma_power_slack", + "group_below_dimension", + "group_bit_router_above_kappa", + "group_gauge_power_slack", + "group_key_fits_record", + "group_positive", + "group_scans_above_kappa", + "halo_covers_generic_inverse_radius", + "improvement_over_user_baseline", + "lambda_above_internal", + "lambda_above_sigma", + "lambda_above_tau", + "lambda_prime_above_lambda", + "lambda_prime_above_leaf", + "leaf_saving_above_effective", + "main_transform_above_kappa", + "membership_arithmetic_fits_record", + "microbox_face_corrections_above_kappa", + "microbox_halo_volume", + "new_complex_uniform_saving_above_b", + "new_semantic_guard_with_C1_one", + "polynomial_products_above_kappa", + "positive_layout_slack", + "q_below_effective", + "q_below_internal", + "q_below_leaf", + "q_positive", + "short_record_fallback", + "source_axis_superpolynomial", + "sparse_union_movement_above_kappa", + "stop_below_one", + "stop_positive", + "strassen_integer_power_gap", + "support_router_span", + "theta_positive_polynomial_power", + "union_header_fits_record", + "union_tag_work_per_visit_fits_record" + ] + }, + "status": "PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY", + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 990, + "9": 5724 + }, + "tested": "2216372947/800000000000", + "tuple": { + "ambient": 145, + "cutoff": 17, + "floor": 21, + "logarithm_power": 55, + "offset": "1/10", + "tensor_power": 256, + "theta": "15/16" + }, + "whole_scientific_admission": false + }, + "precision": { + "carrier_H": 11738348, + "carrier_gap": "616372947/5600000000000", + "carrier_j": 1292, + "expanded": { + "A0": "2^128", + "D0": "2^1048576", + "M": "F16(2^11738348)", + "N": "2^11738348", + "actual_counts_bound": "W,P,U,O,R,G <= M", + "no_old_raw_or_expanded_caps_reused": true, + "precision": "Zbar=2M; Ebar=64*(4M+N+1)^3; Bbar=M+Ebar; C0bar=32*N*Bbar^2; C1=1", + "recursion": "F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)", + "stock": "[W*(O+1)]^Dord(d) times BIT stock and each additional independent live stock", + "strictified_log_upper": 146461 + }, + "status": "PASS_SCOPED_V16C_PRECISION_STOCK_AND_FRESH_RAW_MAJORANTS" + }, + "precision_baseline_conservativity": null, + "proof_substitution_sites": 7 + } + ], + "fresh_baseline": { + "engines": [ + "source-loading", + "helper-aliases", + "local", + "global", + "caller-binding", + "invoice-funding", + "precision", + "conjunction" + ], + "status": "PASS_CONDITIONAL_COMPLETE_NEUTRAL_CALLER_AND_FUNDED_KAPPA" + }, + "own_code_sha256": { + "application.py": "927c1b21bba646f93f94df1685fa549a3d5b1a9cc6b32689e9c03e38adbdac1e", + "frontier.py": "2d1837eed6e828298f4e02ca9105ed4595b2d305354477e42b97fb3ad20d27fc", + "verify.py": "94e310ef92af738dba2322dd5268f795e906bd06b1a5b147494ed721c72a8fa8" + }, + "schema": "pr5413-carrier-frontier/1", + "scope": "Conditional carrier size improvement at fixed or explicitly weaker saving. No raw profile/root improvement, global minimum, practical runtime or unconditional theorem.", + "source_count": 145 +} diff --git a/research/pr5413-carrier-frontier/SOURCES.json b/research/pr5413-carrier-frontier/SOURCES.json new file mode 100644 index 0000000000..2f3d1134af --- /dev/null +++ b/research/pr5413-carrier-frontier/SOURCES.json @@ -0,0 +1,888 @@ +{ + "schema_version": 1, + "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coupled-helper-neutral-completion/.gitattributes", + "usage": "input", + "git_blob": "e50c18de329296aa46874e53f556b90a862b300d", + "sha256": "0004e34a353ed6c35d8806d4529802e72d4697e201c187f8e01d122235943aec" + }, + { + "path": "research/coupled-helper-neutral-completion/CLAIMS.json", + "usage": "input", + "git_blob": "c762467716f42a59014b59bb245953bb523acd5b", + "sha256": "bf4cc5cb47cf85ddd229b35a99e953b1973980e20aef9d16e8edb46ec4a44861" + }, + { + "path": "research/coupled-helper-neutral-completion/COMMANDS.json", + "usage": "input", + "git_blob": "493d083c741746270817e773076d6479e97146e5", + "sha256": "a0de48101c6b8f8771c2d54a762feccf0f2be6c21b078c0d24d1341434ca3fd5" + }, + { + "path": "research/coupled-helper-neutral-completion/README.md", + "usage": "input", + "git_blob": "6a211318c4c5d27e297332820615a645898c88d5", + "sha256": "80274dda57f335073dac5aa4fbbf8678ddd24d352ac62e606e0ce513aab3188f" + }, + { + "path": "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "usage": "input", + "git_blob": "ea9dfc3e40ad7bd5298b3add299b460f3eca11a4", + "sha256": "ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3" + }, + { + "path": "research/coupled-helper-neutral-completion/SOURCE-HISTORY.json", + "usage": "input", + "git_blob": "8999c8f3682bf0fb8d25d551bc76a94ed8f6e4f2", + "sha256": "71fcedd295f18dc7652ea870e8bc9deb65f7294f3a5304fc4706ec4fe09ed80d" + }, + { + "path": "research/coupled-helper-neutral-completion/SOURCES.json", + "usage": "input", + "git_blob": "f3378ec8fbe0598c74c3df48293916cd9a64cf23", + "sha256": "e13a36965dbee5ea5b04206b012da0cd9d6b1b05bb1f2da9f4852b7e9ae1b02c" + }, + { + "path": "research/coupled-helper-neutral-completion/TASK.json", + "usage": "input", + "git_blob": "164c514a896690e67c7c28c50c8aecf9301c0fd9", + "sha256": "b29024224409b50a49a1880f2ebfb0f4f32eefeee4b5463f75c6058fc107e3c3" + }, + { + "path": "research/coupled-helper-neutral-completion/VERIFY.json", + "usage": "input", + "git_blob": "4d1e6c4751008c996075c1ba5c518e328c385375", + "sha256": "727504008c3a4d9b43046ffd3ab3197b1f7d10cf1eec5afd5ca9484d38eb1347" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "usage": "input", + "git_blob": "cddadb2ce1f13393a63d739e92c7964a0403f27d", + "sha256": "bf328da5849a07eadad07e072252894acdc231915d0039df511d70d5d57955d3" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "usage": "input", + "git_blob": "c50958cf8d98edb9f1ff2f190c4df5016e5a2829", + "sha256": "14536ff6baf8b4a8bce96b6a35b5b6acbb9d416d83d9230a903e0d776c6edc02" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "usage": "input", + "git_blob": "04c6c7f36cb1b9fcf0b464bad3d3d83aaae7c864", + "sha256": "cc297ee54c2743615dfe857838d5f40424ccd33fdb08ecfafbc41b1710416d91" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "usage": "input", + "git_blob": "975714d0c15714070b2303ca48d31871f2095210", + "sha256": "1f17fda221bc781ca0b2a120916ed500ba84c305a916a65436a5d6c72d116bcf" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "usage": "input", + "git_blob": "0bbe283da6ab0874d78f6a6119952e75197f081e", + "sha256": "dfa125a8c26b86cfa2024edab9f8ed3c95ebe23bffc1bedfd3c90aa471e80ae0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "usage": "input", + "git_blob": "933b2234afa8c264b09c9b1096ae520e73c3432e", + "sha256": "ecefd9b890ccaa46e9f00a6e43faf16aaaf8ec8c992ab48bf245af38aa3e3f23" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "usage": "input", + "git_blob": "b868fe46ce7ff96a51f7b612758685a23014d31d", + "sha256": "a02e79fb4615f4f987e3b3617c2b42eea2c1d7415cc66fa702a8b0cd28e6387e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "usage": "input", + "git_blob": "faed00ed09bb24a99b8136aadcecf6b3832c72d1", + "sha256": "6fc67329c2772538be6f278e9787782ad064306917e3bb40889f4cef6421d41a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "usage": "input", + "git_blob": "856b4599eb999310ce693ba2f3db12663ecc50db", + "sha256": "438ead22afb57bd72275fdf6fd36e680918309d6492b6165e79c3ff7ea94c424" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "usage": "input", + "git_blob": "8cd6f8829e19b845a5df477353564cbf7abb88d7", + "sha256": "8296ae58fdbb45515d2b3e0158355804ade22c1c579d940c889c228dc1823891" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "usage": "input", + "git_blob": "60df54f0363f3eb26105b753f2432955d4468449", + "sha256": "63bd9003395cfdc2308f6f875464bb57ef6ca708759d5ea468dea74b300bfc92" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "usage": "input", + "git_blob": "9a2d8a37b80b613641f296d6c1edb69459c46298", + "sha256": "2253a106e5edeade264c8ca7cffdaeba1dacabc34a8635fa7a396d877dd723d4" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "usage": "input", + "git_blob": "579364b284d5c19c96135293e90b314ff1b2e3ea", + "sha256": "84df3e63ea1f185b61ed32a73c588373063ccbba90d94db9c1d5202f47ed5af2" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "usage": "input", + "git_blob": "3bf73d72cf1b91ac8a99747eab6e1b3d5aee1d4a", + "sha256": "1ce00ce7a0fc5f97eb9e8992b8b5d92195745d8ec289cd81d82201cd712d7305" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "usage": "input", + "git_blob": "0dd60294b2cf252774a7f9c4d5f27e22a1633e07", + "sha256": "8c874ecaf4d3824876c59d9868721bf237836acaef23ded3b58e6c1e6fca1ae9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "usage": "input", + "git_blob": "1acd6f7b1dce17d1d08911be68ffa017e9466014", + "sha256": "fbf04da0aeacaa8b9a56fa52c3c9b37449818ace7e5abed963ae03203a81f8eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "usage": "input", + "git_blob": "bf31af785122dea7cbceacbfa64c21e567e4fca7", + "sha256": "cf7439c9eb4095224126dd5eefc9f1c5dfe1968d6e8eca5b87d4a3897841182d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "usage": "input", + "git_blob": "444398e7bebee418b5bc9b52ef8702fa95d6bcd5", + "sha256": "e445e7da76e9d8e5dbad2c5fc0bd8aa17e3f5c6d0bfcf56f778c3960426909a1" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "usage": "input", + "git_blob": "ac6d803cf61b3be5031144283129ef899d6dca50", + "sha256": "dbdd056bece96b5c519336a7a1c44d2d9d8e84d134783d156a955bf472405f24" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "usage": "input", + "git_blob": "2114f57aa64c26b5a14917eeafa2a76fadac948f", + "sha256": "4292f2f93e91b556be3114f5aae2853ce9acd747619729b54badd2af97315eea" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "usage": "input", + "git_blob": "574c1d0bd75cd85f720991d815272738aa3e5b8f", + "sha256": "cda8f596f7854f42a228f757d5f8e68f6b2256a19c5ae3771fb40753cedc5b39" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "usage": "input", + "git_blob": "606dc5997217213d9bc1dfa7ebe6bb6f861f8530", + "sha256": "1bd319a30febee6053d24204442c827e1ee7216d70457311b9863a809786887a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "usage": "input", + "git_blob": "dab8936f66b856a829f52c8d87184a0f72d6c9e2", + "sha256": "c4bcb367b6e087a43b5db21e429b71dd845a18efb475c71fd37eb26bfc7430bd" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "usage": "input", + "git_blob": "4a264e2cec4db789bf6fea865511684f11fad3ff", + "sha256": "5a3385aaddb632e4e23372d73b104455e2824d15782df9df0458069e824f969e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "usage": "input", + "git_blob": "0c1a1ec8e22b183861b2a6db9f94126687ecc926", + "sha256": "b0fb7538240b08557689cf47384ecbe9708697f5576db1f1f33dce7119dd8375" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "usage": "input", + "git_blob": "bfe0f019bef756a698ce5a0d31f9229f1e1dc834", + "sha256": "5e2385eaae212161900cc98be2e07db8fdb96ef511edba2aff0a3c47d23a771c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "usage": "input", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "usage": "input", + "git_blob": "7ee84b30892f7354e1c36611f1a5e9b082dc6147", + "sha256": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "usage": "input", + "git_blob": "3ccee4f7645729889b4d38aaa69e6768db59dbd3", + "sha256": "e5b325235eeb6c976a8dc568df838f609fcca0f52945f00bb6b2e9a973a1a11b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "usage": "input", + "git_blob": "4959f78b9f940012d2d58f21d5b7148d73a61fe9", + "sha256": "15e90b63c5659090f02902cb38951ec4ab252352fb0b967b411ed547c501e2ba" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "usage": "input", + "git_blob": "013d48050eb69a73e2dbe387171289fabe8cd7f0", + "sha256": "a37fa9735bbb2697811de72a706b243842d1303243f6e6a0300bd5046d4f3d66" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "usage": "input", + "git_blob": "92d0d7e523dbf90c67b7244de4c87cc74c0d3b61", + "sha256": "0d86590c471a498f3b735397d42bbaf4d5e89c33b75ddbd48dbf972192ab351f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "usage": "input", + "git_blob": "7a16a7dfc2a4a09c55fe0ad8b90afc0a19c25fc8", + "sha256": "fc2e447a0043f74b133a24b67b2a87e4ff87232dd8a003253d19dbf2390a9092" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "usage": "input", + "git_blob": "dd77397ca519f0c15799b4f90a489af3d6a2cb0f", + "sha256": "f16756004bd3100e4993b250181c4c8d15c31b0a1478b627091dd900e1103888" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/engine_adapter.py", + "usage": "input", + "git_blob": "3825fd0799dac2f19360c75c26d1ff3bd3ec323d", + "sha256": "4a3de4a9ca3d65d0485826aa17368789015af7815e7febd74d335302b7dfb42b" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/APPLICATION-SOURCE-TEXTS.json", + "usage": "input", + "git_blob": "dfdb198fefa4095c64d72fdb2d31f21ef03b4fa4", + "sha256": "f9d891b1f09a28f4c5c6f63c895b20ae33ce2b353f9a269fc1e915b0c7fb6703" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/FINAL-GUARD-BINDING.json", + "usage": "input", + "git_blob": "5987c2f097d6d174beca81a4b5836b88c96a33b4", + "sha256": "fb12757d38bb76bcdb395560a770a2459ba0b86be499eca8868124fd0137ebc7" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/GUARD-CONTROLS.json", + "usage": "input", + "git_blob": "d426f74de31f68ede377c45c008601e909686326", + "sha256": "8bc2281474aa97939fc7feba6b8ffefc5f1096ad35f4c9b2dc0e6934e3309cdd" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/adapter-control/RESULT.json", + "usage": "input", + "git_blob": "dbac7562b3359a92ee25abd8d5ae78bfe47912b7", + "sha256": "bb91b419f4f63dd8f1abb1e378915cebae27cf27508fe196291c4385232b0847" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/adapter-control/assert_module.py", + "usage": "input", + "git_blob": "47bb6b45b4f4664fefd2737fa6ca15fc635261b8", + "sha256": "d21f5ca2be32947ced4661abdcba43c73f766bcb86016cdd4a2f239f695d8eb9" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/adapter-control/direct_spec.py", + "usage": "input", + "git_blob": "5941fe3ab59c1f9cf85b3def5e3e1d5b7488eaeb", + "sha256": "25d1a360aa5714c01d8a208df39c770989e3b32806af45e17b5168f613fe969c" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/NOTICE", + "usage": "input", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/coded-native-caller/NOTICE", + "usage": "input", + "git_blob": "985b6b1bc76dacd54a9cbe9897f3b659ae93c3a4", + "sha256": "317b1c5e040bab50ebfc3d0cdb3a47fc30e2f872a00895f563d7931749b1cc7b" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "usage": "input", + "git_blob": "7ee84b30892f7354e1c36611f1a5e9b082dc6147", + "sha256": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-compiler-refill/ENDPOINT.md", + "usage": "input", + "git_blob": "fe591883cfe85e869fd131579f7c2f339c47e721", + "sha256": "9b8d08cddbe8cbaeffee9d83ace37ae55b7432e534649bd8a6eabe670d5388ae" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "usage": "input", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/copied-sources/pr5402/research/native-rank8-helper-provider/ATTRIBUTION.md", + "usage": "input", + "git_blob": "efe3acb566448caeb4a340235bb50234808ff728", + "sha256": "29756f86ebad2a957d8073bea173306f00e7d957828a5bab9f7832faf5815543" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/inherited5407/SOURCE-CUSTODY.json", + "usage": "input", + "git_blob": "8ad6043f621036f14484611e965a5f845d9d5e1f", + "sha256": "8c6b31227593ec62e5f36c944ce761bfe01dccaf12a0ee26143031b0c57d1dbf" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/origins/canonical.json", + "usage": "input", + "git_blob": "33c24fcca7dbd112ed14c4df2fbce4ba7d88aaf3", + "sha256": "bffd95044b1f9c60a8c04a909839d1c768ce578c48ccc2f9ad646c347338facf" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/origins/pr5398.json", + "usage": "input", + "git_blob": "706b854d7c32bd28dfe9703a2ce66a8f5354b2b9", + "sha256": "a5ee90cb3711c0bc147de7b2a1d251791e6918fc3c0d2d87926b2cd49080df4b" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/origins/pr5400.json", + "usage": "input", + "git_blob": "742fc58a2a70a457970b8a335cbd84c730297f28", + "sha256": "379c3cf94afcd0eec5bd062aff03515ecaaccdb586e157840e4a16a28e86099c" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/origins/pr5402.json", + "usage": "input", + "git_blob": "161ffba582f717a6277a77b756790bdec200d7d4", + "sha256": "c990896bcc5419bd4fbca7f5f688692733c67bc1dc7c3d41c60153315392afd7" + }, + { + "path": "research/coupled-helper-neutral-completion/provenance/origins/pr5407.json", + "usage": "input", + "git_blob": "b230a241cef536c7049786d3238a1a408fdfb39b", + "sha256": "31717020b0244b36deed7e14ea2612dab6effc3d83d9e98b561c58e76ee8453e" + }, + { + "path": "research/coupled-helper-neutral-completion/receipt_guard.py", + "usage": "input", + "git_blob": "411a923e193d1cf42043251a6b20a0d859983cf9", + "sha256": "367e385862c9c8a907dbd95b9cc83934420bd518cc8bee263dcff68732785c35" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/acceptance/FINAL-GATE-REVIEW.json", + "usage": "input", + "git_blob": "a22fa13fb83bc2924e433be7b1fb5b1f4e75e118", + "sha256": "601eb04ddbd1becdeed02350ace47e47a4cfbeba577bbb802fcb4d5107f43b81" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/acceptance/NEUTRAL-PROOF-v16c.md", + "usage": "input", + "git_blob": "f29713683c3f12b934aceeedd15a631132cf67ee", + "sha256": "dca94625cd0d49de6b81e4a7dd4108b8b6f711e90496d9116806242d30b35737" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/acceptance/REPORT-final-v16c.md", + "usage": "input", + "git_blob": "927ebb1b7451d2bc923b9bc173a983abe2bfc3c1", + "sha256": "8f67c34245874063a4ebd10f0934c4ab9744752fbcc34e2032ded7099cab3db7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/README.md", + "usage": "input", + "git_blob": "ce05a28a05d6dc9c197d08134ef075cfc94c74c4", + "sha256": "cb995cdbcca9b7f8d8d10349995f44bd9ae43911213cec81f85a2bd86080d54e" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-CALLER-IMPLEMENTATION-v2.json", + "usage": "input", + "git_blob": "5490f9a16db6022274532e7a4446002e72142fc5", + "sha256": "c14d7f014dc3fa990a56574e877692feba23f886e1106390dbc3f06fbed2544b" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-CALLER-IMPLEMENTATION.json", + "usage": "input", + "git_blob": "7976120db89ab6b9367e02b3c9cc59a6d9d7ef7a", + "sha256": "136bf84b422c4012ff2bf98d742ca5c8c42209176d7c73fa001d6c07b7ab6b91" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-PRECISION-v1.json", + "usage": "input", + "git_blob": "ce839111f7e5c2803832563e1d23eb8a60b91135", + "sha256": "1e19f9f8880e7e37199a28754a4587c1a4ac7d1dfe359cba94d4367a6acd6161" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-PRECISION-v2.json", + "usage": "input", + "git_blob": "f61cb48ab376215dfd0a8f23137881f96d6fdbeb", + "sha256": "6795df1aed217a4b9930123dfac9b5a650f309453ea9f18a5cec4cde138cf5cd" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-SOURCES-v2.json", + "usage": "input", + "git_blob": "de3bc846afd838383e10575f0424a4ab60dbc973", + "sha256": "bba00fbf18a854ede567c49239807a14bebbad6c04fc872b45014026088703f5" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-SOURCES.json", + "usage": "input", + "git_blob": "22e3b686056b1477067ee453e1b90881faba7c78", + "sha256": "b17391a49909e9b9a013483e9723053be2a0199029f74294b942e10531c059b7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/V16-V1-ORDER-DIAGNOSTIC.json", + "usage": "input", + "git_blob": "5c977c48e225b60275b06a5dbac7a4dda15c2c1a", + "sha256": "c11d05fb05b72c64d27545b225140bab5536b7465304dc65e43aacf0765e2cfc" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/check_v16_precision.py", + "usage": "input", + "git_blob": "00cb7f42ab44c5b8f19fdb4707bf80e4878f1292", + "sha256": "7c1dbc17a3e4a790afc9e15307669f2460492a3e24ba49452714375ef368f7fc" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/check_v16_precision_v2.py", + "usage": "input", + "git_blob": "e7f8a7f17742c237910683b76fac812f77014746", + "sha256": "872be7074b4911497e9c60995fc70e72309ddaf8a3d43c534a8b289c3b821b26" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/diagnostics/prepared-unexecuted-helper-alias-v1.py", + "usage": "input", + "git_blob": "5f946342d2c3e1834e1f79b19aa22e9d3870f3f6", + "sha256": "aa7fc322e08e94a53b1057f5f3a7b4f6bca3808341e9de92cc5223bd5c8b5df4" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/global.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/local.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/source-loading.json", + "usage": "input", + "git_blob": "44b5b599730b6f7bbf6084a60a4fe9b1ee271297", + "sha256": "751bb2ffaadfdc2cd430ec9841fe572d70031f77e42e375ec02664ebb98760bf" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/inherited/swarm-next-gain-sol-high-20261024/agents/acceptance/REVIEW-EVIDENCE-v2.json", + "usage": "input", + "git_blob": "8785d3596e3a02c15a9d9bc23444dfe4549c9be8", + "sha256": "3cc925c946d0d21e28be9f1968968a9516eb29652d04821f4ff34ce2c69d839e" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/inherited/swarm-provider-audit-sol-high-20261024/agents/algebra/REPORT.md", + "usage": "input", + "git_blob": "ea5d404caea333971c110a1e48793a74e3d51482", + "sha256": "d521185710b93c328b28b3933ea26dda9b5509f563bd5fe0852957daa455c557" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/inherited/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "usage": "input", + "git_blob": "3ccee4f7645729889b4d38aaa69e6768db59dbd3", + "sha256": "e5b325235eeb6c976a8dc568df838f609fcca0f52945f00bb6b2e9a973a1a11b" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/proofs/NEUTRAL-PROOF-v16c.md", + "usage": "input", + "git_blob": "f29713683c3f12b934aceeedd15a631132cf67ee", + "sha256": "dca94625cd0d49de6b81e4a7dd4108b8b6f711e90496d9116806242d30b35737" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/proofs/PINNED-HIGHER-MOMENT.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/proofs/PINNED-OUTER-FAMILY.md", + "usage": "input", + "git_blob": "fe591883cfe85e869fd131579f7c2f339c47e721", + "sha256": "9b8d08cddbe8cbaeffee9d83ace37ae55b7432e534649bd8a6eabe670d5388ae" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/proofs/V16-APPLICATION-PROOF-v3.md", + "usage": "input", + "git_blob": "574c1d0bd75cd85f720991d815272738aa3e5b8f", + "sha256": "cda8f596f7854f42a228f757d5f8e68f6b2256a19c5ae3771fb40753cedc5b39" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/proofs/WHOLECALLER-COMPLETION-THEOREM.md", + "usage": "input", + "git_blob": "933b2234afa8c264b09c9b1096ae520e73c3432e", + "sha256": "ecefd9b890ccaa46e9f00a6e43faf16aaaf8ec8c992ab48bf245af38aa3e3f23" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-global-id-binding-v1/RECEIPT.json", + "usage": "input", + "git_blob": "bfe13a24191d562c7591895b2c9090f190298403", + "sha256": "1459efb7b70c812ddba994bf52ac0b61a7991da602d5247255ff74ed5cc9a95a" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-global-id-binding-v1/stdout.log", + "usage": "input", + "git_blob": "40772ab13ad297626f5e469f1bba94442f3b98c3", + "sha256": "b709711b02a573920046b3bae3ea8c18d299b3ca3f2446075fe1bf4b3e002840" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-helper-aliases-v2/RECEIPT.json", + "usage": "input", + "git_blob": "36fd1de4d608cc3767c8ed02b4389b0f2b7333c1", + "sha256": "de7bff6e60ca78809232125cdde8e0a067dbf2194249136277d3d8eb4635bb59" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-helper-aliases-v2/stdout.log", + "usage": "input", + "git_blob": "2a34b5a38613c091995899d42b231ceaa7150d0b", + "sha256": "f4b47dbac33978bb6335b82f8397a220afb42871e3cf6dc4e36f2a632aa46feb" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-neutral-v16c-r2/RECEIPT.json", + "usage": "input", + "git_blob": "2c4ea3e799860751cb38911cffc6aabf3ff85679", + "sha256": "0d1ca7a36d93b23c4f57de7f6e5cfb1847dcaadebfd79cbdffef99f5ab8a0d56" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-neutral-v16c-r2/stdout.log", + "usage": "input", + "git_blob": "b723a331dc43662c113f9a1c6dd45d1c98052833", + "sha256": "60ac9eac22712971ff77ce8e7635d4c4f4f44f0f9fe56952146052bce9ba35ec" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-mathematical-conjunction-v1/RECEIPT.json", + "usage": "input", + "git_blob": "7ca85e8a2aba5a5c4752d4dfcf56b05b9108b6f1", + "sha256": "c18c56d089853d52a8c05bc91001b253278bb5ce7c9f8cc3393f506d0aa2acaf" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-mathematical-conjunction-v1/stdout.log", + "usage": "input", + "git_blob": "88c0e634ea833a93beb705f9d1bd12c3f7f1eaca", + "sha256": "040c0574023ea63aaa965065603b15d505d9e55c7673be4522f9c8a55eacfa6b" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-v16c-funding/RECEIPT.json", + "usage": "input", + "git_blob": "7d2ca3454e6d2517946eda17aecc35ababee9ac7", + "sha256": "de0197a5c28e69599b8f61b98a00670bdabd6487d6082763c94d3791362417e0" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-v16c-funding/stdout.log", + "usage": "input", + "git_blob": "8c50fccfcf280a0ee551e0a9ec8f25c00aa1f2d8", + "sha256": "26a302424d7311d6141cbf4971087dac5711be14d9b03733b8e160965e26fc0a" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-v16c-fresh-precision-v3-canonical145/RECEIPT.json", + "usage": "input", + "git_blob": "2e3c003e8269b846f3b3d4f27d2791ee5257672f", + "sha256": "e828a0dbd633a61e54ad083d49552a9e714ed2298264a62a58d2f6b5a76c88b0" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-v16c-fresh-precision-v3-canonical145/stdout.log", + "usage": "input", + "git_blob": "3d4901d7d6b1e23483e130f2f279def8bab4d851", + "sha256": "dfaadf6362c5470e49ce7c4fceaf47da97402476918a7a3078c5caef6f5e242d" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-wholecaller-v1/RECEIPT.json", + "usage": "input", + "git_blob": "3d118021b47a7d757f5ebd27de9e3e1b6a185b12", + "sha256": "c8888847d58aa9dc5c47bf0dbb6164b4ce688c143cdd3d32161e5d7092e32dfa" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-wholecaller-v1/stdout.log", + "usage": "input", + "git_blob": "6aa981f7ceb1c0364c2e7de4bf080bb80f56a1ae", + "sha256": "358f3c1caa315ebc753527461a8187c15f277ef0ed61ec864014d688268cf178" + }, + { + "path": "research/coupled-helper-neutral-completion/source_guard.py", + "usage": "input", + "git_blob": "1c2ced5d5610929ed4c1d467540d05977f4b0d29", + "sha256": "1b7b89c87d89a595b501adbc1afcfa477f3eee10e87a4fe8e6b1f2b693fda2ba" + }, + { + "path": "research/coupled-helper-neutral-completion/verify.py", + "usage": "input", + "git_blob": "09619d733f2cac5ba3dc77ff9a01fde6a13178bf", + "sha256": "4e02c4f016d59dd7c15bbd86d07e64727de48ca2a1aca7881fe6ac64258ba678" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "input", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + } + ] +} diff --git a/research/pr5413-carrier-frontier/TASK.json b/research/pr5413-carrier-frontier/TASK.json new file mode 100644 index 0000000000..34b713c64b --- /dev/null +++ b/research/pr5413-carrier-frontier/TASK.json @@ -0,0 +1,106 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63", + "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": "Explicitly assigned fixed-kappa carrier reduction and size-saving frontier on the frozen PR5413 profile, with changed-tuple precision/conjunction checks.", + "scope_change_reason": "The user assigned finite construction size, not a new paid profile, root digit, raw mechanism or independent reimplementation of the source arithmetic.", + "bottleneck_link": "Sufficient template size can be improved independently of the exponent by replacing a coarse paid-tail envelope and retuning compiler parameters.", + "budget_minutes": 60, + "stop_rule": "Accept only complete charged certificates and source-sensitive precision applications; stop before any claim of a materialized practical multiplier or new selected frontier.", + "outcome": "completed", + "evidence": "RESULT.json; fresh unchanged eight-engine caller replay plus five changed-tuple precision/conjunction runs and semantic rejection controls.", + "author": "Richard Hoekstra", + "ai_assistance": "OpenAI Codex; no subagents or independent human review.", + "open_questions": [ + { + "question": "Can source-sensitive tuple admission be reviewed independently?", + "why_it_matters": "The new receipts are conditional and AI-assisted, and neither a numerical certificate nor an adapted conjunction is upstream scientific approval.", + "first_step": "Review PROOF.md, the six changed gate applications and the generated proof instances against the exact pinned source.", + "blocked_by": "No independent human or formal-kernel review is supplied." + }, + { + "question": "Can smaller carriers be obtained by a different compiler geometry?", + "why_it_matters": "Even the smallest shown carrier is astronomically large.", + "first_step": "Apply a source-bound direct/adaptive compiler to this exact profile with a fully charged ordinary and precision bill.", + "blocked_by": "A favorable raw moment alone does not provide that changed caller or gate application." + } + ] +} diff --git a/research/pr5413-carrier-frontier/VERIFY.json b/research/pr5413-carrier-frontier/VERIFY.json new file mode 100644 index 0000000000..e5dd79be35 --- /dev/null +++ b/research/pr5413-carrier-frontier/VERIFY.json @@ -0,0 +1,176 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coupled-helper-neutral-completion/.gitattributes", + "research/coupled-helper-neutral-completion/CLAIMS.json", + "research/coupled-helper-neutral-completion/COMMANDS.json", + "research/coupled-helper-neutral-completion/README.md", + "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "research/coupled-helper-neutral-completion/SOURCE-HISTORY.json", + "research/coupled-helper-neutral-completion/SOURCES.json", + "research/coupled-helper-neutral-completion/TASK.json", + "research/coupled-helper-neutral-completion/VERIFY.json", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "research/coupled-helper-neutral-completion/engine_adapter.py", + "research/coupled-helper-neutral-completion/provenance/APPLICATION-SOURCE-TEXTS.json", + "research/coupled-helper-neutral-completion/provenance/FINAL-GUARD-BINDING.json", + "research/coupled-helper-neutral-completion/provenance/GUARD-CONTROLS.json", + "research/coupled-helper-neutral-completion/provenance/adapter-control/RESULT.json", + "research/coupled-helper-neutral-completion/provenance/adapter-control/assert_module.py", + "research/coupled-helper-neutral-completion/provenance/adapter-control/direct_spec.py", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/LICENSE", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/NOTICE", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/coded-native-caller/NOTICE", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/higher-moment-strictification/README.md", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-compiler-refill/ENDPOINT.md", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/coupled-helper-neutral-completion/provenance/copied-sources/canonical/research/pr4359-p7-padding/source/research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md", + "research/coupled-helper-neutral-completion/provenance/copied-sources/pr5402/research/native-rank8-helper-provider/ATTRIBUTION.md", + "research/coupled-helper-neutral-completion/provenance/inherited5407/SOURCE-CUSTODY.json", + "research/coupled-helper-neutral-completion/provenance/origins/canonical.json", + "research/coupled-helper-neutral-completion/provenance/origins/pr5398.json", + "research/coupled-helper-neutral-completion/provenance/origins/pr5400.json", + "research/coupled-helper-neutral-completion/provenance/origins/pr5402.json", + "research/coupled-helper-neutral-completion/provenance/origins/pr5407.json", + "research/coupled-helper-neutral-completion/receipt_guard.py", + "research/coupled-helper-neutral-completion/reports/acceptance/FINAL-GATE-REVIEW.json", + "research/coupled-helper-neutral-completion/reports/acceptance/NEUTRAL-PROOF-v16c.md", + "research/coupled-helper-neutral-completion/reports/acceptance/REPORT-final-v16c.md", + "research/coupled-helper-neutral-completion/reports/diagnostics/README.md", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-CALLER-IMPLEMENTATION-v2.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-CALLER-IMPLEMENTATION.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-PRECISION-v1.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-PRECISION-v2.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-SOURCES-v2.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-SOURCES.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/V16-V1-ORDER-DIAGNOSTIC.json", + "research/coupled-helper-neutral-completion/reports/diagnostics/check_v16_precision.py", + "research/coupled-helper-neutral-completion/reports/diagnostics/check_v16_precision_v2.py", + "research/coupled-helper-neutral-completion/reports/diagnostics/prepared-unexecuted-helper-alias-v1.py", + "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "research/coupled-helper-neutral-completion/reports/expected/global.json", + "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "research/coupled-helper-neutral-completion/reports/expected/local.json", + "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "research/coupled-helper-neutral-completion/reports/expected/source-loading.json", + "research/coupled-helper-neutral-completion/reports/inherited/swarm-next-gain-sol-high-20261024/agents/acceptance/REVIEW-EVIDENCE-v2.json", + "research/coupled-helper-neutral-completion/reports/inherited/swarm-provider-audit-sol-high-20261024/agents/algebra/REPORT.md", + "research/coupled-helper-neutral-completion/reports/inherited/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "research/coupled-helper-neutral-completion/reports/proofs/NEUTRAL-PROOF-v16c.md", + "research/coupled-helper-neutral-completion/reports/proofs/PINNED-HIGHER-MOMENT.md", + "research/coupled-helper-neutral-completion/reports/proofs/PINNED-OUTER-FAMILY.md", + "research/coupled-helper-neutral-completion/reports/proofs/V16-APPLICATION-PROOF-v3.md", + "research/coupled-helper-neutral-completion/reports/proofs/WHOLECALLER-COMPLETION-THEOREM.md", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-global-id-binding-v1/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-global-id-binding-v1/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-helper-aliases-v2/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-helper-aliases-v2/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-neutral-v16c-r2/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-independent-neutral-v16c-r2/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-mathematical-conjunction-v1/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-mathematical-conjunction-v1/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-v16c-funding/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-neutral-v16c-funding/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-v16c-fresh-precision-v3-canonical145/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-v16c-fresh-precision-v3-canonical145/stdout.log", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-wholecaller-v1/RECEIPT.json", + "research/coupled-helper-neutral-completion/reports/root-runs/coupled-caller-wholecaller-v1/stdout.log", + "research/coupled-helper-neutral-completion/source_guard.py", + "research/coupled-helper-neutral-completion/verify.py", + "research/higher-moment-strictification/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Fresh unchanged PR5413 complete eight-engine replay; five complete charged carrier certificates, 54+4 outer guards, source-bound changed-tuple precision, conservative original precision payload, 19 unchanged AST gates and all 25 adapted conjunction conditions, rejecting controls and deterministic RESULT rebuild." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Optimized wrapper; local and frozen scientific source compiled at optimize=0; same complete scientific payload and rejecting controls." + } + ] +} diff --git a/research/pr5413-carrier-frontier/application.py b/research/pr5413-carrier-frontier/application.py new file mode 100644 index 0000000000..c8cd751406 --- /dev/null +++ b/research/pr5413-carrier-frontier/application.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +"""Explicit changed-tuple adapters for the frozen PR5413 application checks. + +Apache-2.0. Richard Hoekstra with OpenAI Codex assistance. The frozen checker, +written application and conjunction are Chris R/Clear1nsight's, with zxv's +compiler/precision and the retained native/controller lineage. No original +source or frozen manifest is changed: these adapters run only in scratch. +""" +import ast +import copy +import hashlib +import json +import os +import subprocess +import sys +from fractions import Fraction as Q +from pathlib import Path + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def load(path): + return json.loads(Path(path).read_bytes()) + + +def dump(path, value): + Path(path).write_text(json.dumps(value, indent=2, sort_keys=True)+'\n') + + +def substitute(text, pairs): + for old, new in pairs: + need(text.count(old) == 1, 'unique source substitution: '+old) + text = text.replace(old, new) + return text + + +def decimal(x): + x = Q(x) + for digits in range(32): + n = x*10**digits + if n.denominator == 1: + return str(n.numerator) if not digits else '.'+str(n.numerator).rjust(digits, '0') + return str(x) + + +def precision_source(original): + return substitute(original, [ + ('q=1024;ambient_log=8192', + "q=data['funding']['tuple']['tensor_power'];ambient_log=8*q\n" + " need(type(q)is int and 1<=q<=1024,'compiler product domain')"), + ("need(gap==(Q(fund['tested'])-Q(fund['kappa']))/7==Q(1,700000000000),'actual strict compiler gap')", + "need(gap==(Q(fund['tested'])-Q(fund['kappa']))/7 and gap>0,'actual strict compiler gap')"), + ("need(H==j*gap.denominator and (H+1)**1000<2**j,'actual funded carrier rank')", + "power=fund['tuple']['logarithm_power']\n" + " need(type(power)is int and power>0 and type(j)is int and j>1, 'positive carrier parameters')\n" + " need(H==-((-j*gap.denominator)//gap.numerator) and H>8*q and (H+1)**power<2**j, 'actual funded carrier rank')\n" + " need((-((-(j-1)*gap.denominator)//gap.numerator)+1)**power>=2**(j-1), 'preceding carrier grid')"), + ]) + + +def proof_instance(original, case, funding): + v, H = case['v'], funding['H'] + d = Q(funding['gap']) + strictified = 2*(v*(2+2*128)+10+2*(8*v))+6+3*(8*v+1) + need(strictified < 1048576, 'new expanded unit fits retained D0') + pairs = [ + ('At q=1024 and raw maximum145,', f'At q={v} and raw maximum145,'), + ('2*(1024*(2+2*128)+10+2*8192)+6+3*8193=585757<1048576.', + f'2*({v}*(2+2*128)+10+2*{8*v})+6+3*{8*v+1}={strictified}<1048576.'), + ('H=38569300000000000, N=2^H,', f'H={H}, N=2^H,'), + ('The fresh strict tested/claim gap is1/700000000000.', + f'The fresh strict tested/claim gap is {d}.'), + ('log2D0=1048576, while H*gap=55099 and H*r0=5509.9.', + f'log2D0=1048576, while H*gap={H*d} and H*r0={H*d/10}.'), + ('The independent funding file uses K=.003027288235 and tested C=.003027288245,', + f'The independent funding file uses K={decimal(case["k"])} and tested C={decimal(case["s"])},'), + ('reserve10^-12, cutoff20/floor21, offset1/5, product1024, ambient145,\n' + 'theta63/64 and logarithm power1000.', + f'the complete higher-moment paid sum, cutoff{case["c"]}/floor{case["b"]}, offset{case["u"]}, ' + f'product{v}, ambient145,\ntheta{case["theta"]} and logarithm power{case["p"]}.'), + ] + result = substitute(original, pairs) + section = '''## Changed-tuple numerical application + +This instance retains all raw native, owner, field-ID and route bindings. +The admitted higher-moment strictification theorem charges original paid +calls, the last incomplete split block, and completion of each actual owner. +Writing t=1-tested, u>=tested, J=cutoff^q and L=floor^q, its full normalized +paid-moment upper bound is alpha^q+2*gamma_u^q+2*delta^q. Each factor two +includes the residual split block. The exact directed certificate pays all +three terms and verifies their sum is strictly below one. The old .97 tail +envelope and Bernoulli/reserve debit were sufficient bounds on these same +jobs; they are replaced, not added as separate physical work. + +The logarithmic compiler uses the new rational theta and positive integer +logarithm power, checking the true and shifted exit contractions, eta and +the full ordinary initial range. The carrier grid is H=ceil(j/gap), so +2^j<=2^(gap*H); the strict comparison (H+1)^power<2^j funds the same uniform +exponent. The unchanged four parameter layers use positive rational gap, +not a requirement that its numerator equal one. All 54+4 outer inequalities +are freshly checked. No old precision constant is reused from a smaller +raw template: the same fixed D0=2^1048576 dominates this new unit's explicit +count/height overestimate, and the source F16(N), stock and eventual outer +absorption arguments are reapplied at the new N. The five original +framework assumptions remain premises. + +''' + result = result.replace('## 6. D0 is not absorbed at the fixed carrier rank', + section+'## 6. D0 is not absorbed at the fixed carrier rank', 1) + return result, pairs + + +def closure_source(original, case, funding, proof_sha): + k, s, gap, H, j, power = case['k'], case['s'], Q(funding['gap']), funding['H'], funding['j'], case['p'] + replacements = { + 'exact_new_positive_endpoint_gap': f'''gate('exact_new_positive_endpoint_gap', + F['case']=={case['name']!r} and k==Q({str(k)!r}) and c==Q({str(s)!r}) + and gap==(c-k)/7==Q({str(gap)!r}))''', + 'fresh_alpha_both_tails_completion_eta': '''gate('fresh_alpha_both_tails_completion_eta', + verify_funding(root,F) and all(F['predicates'].values()) + and Q(F['alpha_upper'])<1-Q(F['reserve']) + and Q(F['completion_slack'])>0)''', + 'strict_minimum_rounding_reserve': f'''gate('complete_paid_split_and_completion_bill', + F['charging_model']=='complete-higher-moment-sum-with-both-partial-block-tails' + and Q(F['original_paid_upper'])>=Q(F['alpha_upper'])**{case['v']} + and Q(F['higher_tail_upper'])>=2*Q(F['gamma_upper'])**{case['v']} + and Q(F['completion_tail_upper'])>=2*Q(F['delta_upper'])**{case['v']} + and Q(F['normalized_paid_upper'])==sum(Q(F[x])for x in + ['original_paid_upper','higher_tail_upper','completion_tail_upper'])<1)''', + 'fresh_height_and_preceding_height_grid': f'''gate('fresh_height_and_preceding_height_grid', + H=={H} and j=={j} and H==ceilq(Q(j)/gap) and H>{8*case['v']} + and (H+1)**{power}<2**j + and (ceilq(Q(j-1)/gap)+1)**{power}>=2**(j-1))''', + 'fresh_constructive_F16_semantic_stock_bound': f'''gate('fresh_constructive_F16_semantic_stock_bound', + expanded['strictified_log_upper']=={572*case['v']+29}<1048576 + and expanded['D0']=='2^1048576' and expanded['M']==f'F16(2^{{H}})' + and expanded['N']==f'2^{{H}}' and expanded['actual_counts_bound']=='W,P,U,O,R,G <= M' + and expanded['recursion']=='F16(0)=D0; X_n=(n+1)*(D0+1)*(F16(n-1)+1); F16(n)=X_n^(16*(n+1)^2)')''', + 'accepted_written_source_specialization': f'''gate('accepted_written_source_specialization', + digest('precision_proof')=={proof_sha!r} + and all(P['mathematical_application'][name].startswith('PROVED')for name in + ['ordinary_class_specialization','expanded_construction','precision_stock_tape','recovery_class']))''', + } + tree = ast.parse(original) + calls = {node.args[0].value: node for node in ast.walk(tree) + if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == 'gate' + and node.args and isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str)} + need(len(calls) == 25 and set(replacements) <= set(calls), 'original 25-premise inventory') + lines = original.splitlines(keepends=True) + for name in sorted(replacements, key=lambda name: calls[name].lineno, reverse=True): + node = calls[name] + replacement = '\n'.join(' '+line for line in replacements[name].splitlines())+'\n' + lines[node.lineno-1:node.end_lineno] = [replacement] + adapted = ''.join(lines) + adapted = adapted.replace('def conjunction(root,manifest):', + 'from carrier_frontier import verify_funding, ceilq\n\ndef conjunction(root,manifest):', 1) + adapted = adapted.replace("'gain_type':'tiny compiler/outer headroom; zero recursive economic gain'", + "'gain_type':'smaller carrier; unchanged or explicitly weaker exponent; zero recursive economic gain'", 1) + other_calls = {node.args[0].value: node for node in ast.walk(ast.parse(adapted)) + if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == 'gate' + and node.args and isinstance(node.args[0], ast.Constant)} + unchanged = sorted(set(calls)-set(replacements)) + need(len(other_calls) == 25 and len(unchanged) == 19, 'changed conjunction inventory') + for name in unchanged: + need(ast.dump(calls[name], include_attributes=False) == ast.dump(other_calls[name], include_attributes=False), + 'unchanged physical/source premise: '+name) + return adapted, unchanged + + +def run_engine(package, workspace, engine, arguments): + env = {k: v for k, v in os.environ.items() if not k.startswith('PYTHON')} + env['PYTHONDONTWRITEBYTECODE'] = '1' + run = subprocess.run([sys.executable, '-I', '-B', str(package/'engine_adapter.py'), + str(workspace), engine, *arguments], cwd=workspace, + env=env, capture_output=True, timeout=120) + return run.returncode, run.stderr.decode(errors='replace') + + +def manifest(original, changes, workspace): + result = copy.deepcopy(original) + for row in result['rows']: + if row['id'] in changes: + row['path'] = changes[row['id']] + row['sha256'] = sha(workspace/row['path']) + if 'by_id' in result: + result['by_id'].update(changes) + return result diff --git a/research/pr5413-carrier-frontier/frontier.py b/research/pr5413-carrier-frontier/frontier.py new file mode 100644 index 0000000000..8781900ee6 --- /dev/null +++ b/research/pr5413-carrier-frontier/frontier.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Source-bound carrier certificates, retaining the complete PR5413 invoice. + +Apache-2.0. Richard Hoekstra, with substantial OpenAI Codex assistance. +The higher-moment/logarithmic compiler is zxv's; the mixed flow is Jacob +Alan Sussman's. Arithmetic helpers and the outer ledger are authenticated +public sources credited to Chris R/Clear1nsight and their retained lineage. +This module does not independently reimplement those arithmetic helpers. +""" +import copy +import hashlib +import json +from fractions import Fraction as Q +from pathlib import Path + +AGENTS = 'swarm-coupled-caller-sol-high-20261024/agents/' +INVOICE = AGENTS+'invoice/' +PRECISION = AGENTS+'precision/' +TEMPLATE = 'carrier-frontier/BASELINE-FUNDING.json' +TEMPLATE_SHA = '70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb' +MOMENTS = INVOICE+'exact_moments.py' +MOMENTS_SHA = 'cf7439c9eb4095224126dd5eefc9f1c5dfe1968d6e8eca5b87d4a3897841182d' +OUTER = 'swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py' +OUTER_SHA = '9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47' +BASE_K = Q('0.003027288235') +BASE_S = Q('0.003027288245') +CASES = [dict(name='fixed-kappa', k=BASE_K, s=BASE_S, v=1024, c=18, b=21, + u=Q(1, 10), theta=Q(61, 64), p=322, H=12040700000000000, j=17201)] +for name, k, v, p, H, j in [ + ('saving-003', Q('.003'), 512, 120, 1239850102, 3625), + ('saving-00275', Q('.00275'), 256, 59, 50859231, 1511), + ('saving-0025', Q('.0025'), 256, 58, 25258797, 1427), + ('saving-002', Q('.002'), 256, 55, 11738348, 1292), +]: + CASES.append(dict(name=name, k=k, s=k+Q(3, 4)*(BASE_S-k), v=v, c=17, b=21, + u=Q(1, 10), theta=Q(15, 16), p=p, H=H, j=j)) + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def load_source(root, relative, digest): + path = root/relative + need(sha(path) == digest, 'changed public arithmetic input: '+relative) + space = {'__name__': '_carrier_public_helper', '__file__': str(path)} + exec(compile(path.read_bytes(), str(path), 'exec', dont_inherit=True, optimize=0), space) + return space + + +def ceilq(x): + return -((-x.numerator)//x.denominator) + + +def upper(x): + scale = 2**192 + return Q(ceilq(x*scale), scale) + + +def grid(p, gap): + need(type(p) is int and p > 0 and 0 < gap < Q(1, 16), 'proved positive carrier-grid domain') + def at(j): + return ceilq(Q(j)/gap) + def wins(j): + return (at(j)+1)**p < 2**j + low, high = 1, 2 + while not wins(high): + low, high = high, 2*high + while high-low > 1: + mid = (low+high)//2 + if wins(mid): + high = mid + else: + low = mid + need(wins(high) and not wins(high-1), 'first successful sufficient height grid') + return at(high), high + + +def certify(root, case): + need(sha(root/TEMPLATE) == TEMPLATE_SHA, 'frozen complete source invoice') + baseline = json.loads((root/TEMPLATE).read_bytes()) + E = load_source(root, MOMENTS, MOMENTS_SHA) + ledger = load_source(root, OUTER, OUTER_SHA)['ledger'] + power, moment = E['power'], E['moment'] + P, T = ({int(r): n for r, n in baseline[key].items()} for key in ('paid', 'targets')) + need(sum(P.values()) == 64260 and sum(T.values()) == 10928, 'full source profile') + k, s, v, c, b, u, theta, p = (case[key] for key in ('k', 's', 'v', 'c', 'b', 'u', 'theta', 'p')) + t, d = 1-s, (s-k)/7 + target, paid = moment(T, t), moment(P, t) + alpha = upper(paid[1]/target[0]) + gamma = upper(moment(P, t+u)[1]/(power(c, u)[0]*target[0])) + delta = upper(Q(b*sum(T.values()))/(power(c, s)[0]*target[0])) + original_paid = upper(alpha**v) + higher_tail, completion_tail = upper(2*gamma**v), upper(2*delta**v) + complete = original_paid+higher_tail+completion_tail + eta = (1-s)*power(145, -v*s)[0] + H, j = grid(p, d) + n, den = theta.numerator, theta.denominator + predicates = dict( + ordered_savings=0 < k < s < Q('.0034'), raw_moment=target[0] > paid[1], + funded_alpha_reserve=alpha < 1-Q(1, 10**12), higher_moment_domain=u >= s, + positive_partial_block_charges=higher_tail > 0 and completion_tail > 0, + exact_completed_moment=complete < 1, split=1 < c < b < 145, + true_exit_exponent=c**den < b**n, + shifted_exits=2**(den-n)*c**(v*den) <= 145**(v*n), + eta=eta > theta**p, initial_range=power(145, v*s)[1] < 2**p, + height=H > 8*v and (H, j) == (case['H'], case['j'])) + need(all(predicates.values()), 'unfunded carrier predicates: '+str(predicates)) + parameters = dict(kappa=k, tested_saving=s, complex_uniform_saving=k+6*d, + b=k+5*d, a=k+4*d, q=k+3*d, bit_saving=Q('.0034'), + bit_atom=Q('.004'), epsilon=1-d, beta=1-3*d, r0=d/10, + stop=d, layout=d, d=d) + margins, strict, functional = ledger(parameters) + need(set(strict) == set(baseline['source_predicates']['strict']) and + set(functional) == set(baseline['source_predicates']['functional']), '54+4 source inventory') + need(len(strict) == 54 and len(functional) == 4 and + min(strict.values()) > 0 and min(functional.values()) > 0, 'strict full outer ledger') + result = copy.deepcopy(baseline) + for obsolete in ('strict_minimum_rounding_reserve', 'reserve_above_minimum', + 'reserve_slack', 'preceding_grid_fails'): + result.pop(obsolete, None) + result.update(case=case['name'], kappa=k, tested=s, gap=d, H=H, j=j, + tuple=dict(ambient=145, cutoff=c, floor=b, offset=u, tensor_power=v, + theta=theta, logarithm_power=p), + raw_tested_margin=(target[0]-paid[1], target[1]-paid[0]), + alpha_upper=alpha, gamma_upper=gamma, delta_upper=delta, eta_lower=eta, + normalized_paid_upper=complete, original_paid_upper=original_paid, + higher_tail_upper=higher_tail, completion_tail_upper=completion_tail, + completion_slack=1-complete, reserve_slack=1-Q(1, 10**12)-alpha, + predicates=predicates, outer=dict(parameters=parameters, margins=margins, + strict=strict, functional=functional, minimum_strict=min(strict.values()), + minimum_functional=min(functional.values())), + gain_over_comparison=k-Q('.00302728823'), + charging_model='complete-higher-moment-sum-with-both-partial-block-tails', + grid_success=True, preceding_grid_fails=True, + grid_scope='First j on H=ceil(j/gap) for this sufficient logarithmic majorant; no global template minimum.', + controls={}, possible_gain_type='smaller carrier at unchanged or explicitly weaker exponent saving', + scope='Source-bound numerical carrier certificate only; changed-tuple precision and physical conjunction are separate checks.') + return encode(result) + + +def verify_funding(root, received): + cases = [c for c in CASES if c['name'] == received.get('case')] + need(len(cases) == 1 and certify(root, cases[0]) == received, + 'complete changed-tuple funding certificate differs from exact rebuild') + return True diff --git a/research/pr5413-carrier-frontier/verify.py b/research/pr5413-carrier-frontier/verify.py new file mode 100644 index 0000000000..14f1248eb1 --- /dev/null +++ b/research/pr5413-carrier-frontier/verify.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python3 +"""Complete caller replay and changed-tuple carrier application. + +Apache-2.0. Richard Hoekstra, with substantial OpenAI Codex assistance. +The unchanged source engines retain Chris R/Clear1nsight and their full lineage. +""" +import argparse +import copy +import difflib +import shutil +import subprocess +import sys +import tempfile +import types +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SRC = ROOT/'research/coupled-helper-neutral-completion' +BINDINGS_SHA = 'ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3' + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def local_module(name): + path = HERE/(name+'.py') + module = types.ModuleType('_carrier_'+name) + module.__file__ = str(path) + exec(compile(path.read_bytes(), str(path), 'exec', dont_inherit=True, optimize=0), module.__dict__) + return module + + +F, A = local_module('frontier'), local_module('application') + + +def input_hashes(): + need(A.sha(SRC/'SOURCE-BINDINGS.json') == BINDINGS_SHA, 'fixed PR5413 capsule manifest') + result = {} + for row in A.load(HERE/'SOURCES.json')['files']: + if row['usage'] == 'input': + need(A.sha(ROOT/row['path']) == row['sha256'], 'live input changed: '+row['path']) + result[row['path']] = row['sha256'] + return result + + +def precision_run(ws, manifest_path, output): + fixed = ws/F.PRECISION/'V16-SOURCES-v3.json' + original = fixed.read_bytes() + try: + fixed.write_bytes(manifest_path.read_bytes()) + return A.run_engine(SRC, ws, F.PRECISION+'check_carrier_precision.py', + ['--root', '.', '--output', F.PRECISION+output]) + finally: + fixed.write_bytes(original) + + +def case_application(ws, case, first, proof_output=None): + pdir, idir = ws/F.PRECISION, ws/F.INVOICE + (ws/'carrier-frontier').mkdir(exist_ok=True) + shutil.copyfile(SRC/'reports/expected/funding.json', ws/F.TEMPLATE) + shutil.copyfile(HERE/'frontier.py', idir/'carrier_frontier.py') + funding = F.certify(ws, case) + A.dump(idir/'CARRIER-FUNDING.json', funding) + original_checker = (pdir/'check_v16_precision_v3.py').read_text() + (pdir/'check_carrier_precision.py').write_text(A.precision_source(original_checker)) + original_manifest = A.load(pdir/'V16-SOURCES-v3.json') + conservativity = None + volatile = {'seconds', 'checker_sha256', 'input_manifest_sha256'} + if first: + path = pdir/'ORIGINAL-SOURCES.json' + path.write_bytes((pdir/'V16-SOURCES-v3.json').read_bytes()) + code, error = precision_run(ws, path, 'CONSERVATIVE-PRECISION.json') + need(code == 0, 'precision conservativity: '+error[-1200:]) + received = A.load(pdir/'CONSERVATIVE-PRECISION.json') + expected = A.load(SRC/'reports/expected/precision.json') + need({k: v for k, v in received.items() if k not in volatile} == + {k: v for k, v in expected.items() if k not in volatile}, 'original precision payload preserved') + conservativity = True + proof, substitutions = A.proof_instance((pdir/'V16-APPLICATION-PROOF-v3.md').read_text(), case, funding) + (pdir/'CARRIER-APPLICATION.md').write_text(proof) + proof_sha = A.sha(pdir/'CARRIER-APPLICATION.md') + pman = A.manifest(original_manifest, + {'funding': F.INVOICE+'CARRIER-FUNDING.json', 'application_proof': F.PRECISION+'CARRIER-APPLICATION.md'}, ws) + pman_path = pdir/'CARRIER-SOURCES.json' + A.dump(pman_path, pman) + code, error = precision_run(ws, pman_path, 'CARRIER-PRECISION.json') + need(code == 0, 'changed-tuple precision: '+error[-1600:]) + precision = A.load(pdir/'CARRIER-PRECISION.json') + need(precision['carrier_H'] == case['H'] and precision['carrier_j'] == case['j'] and + Q(precision['carrier_gap']) == Q(funding['gap']) and + precision['expanded']['strictified_log_upper'] == 572*case['v']+29 and + precision['expanded']['D0'] == '2^1048576' and + precision['mathematical_application']['proof_sha256'] == proof_sha, + 'fresh precision bound to tuple, proof and carrier') + expected = A.load(SRC/'reports/expected/precision.json') + allowed = volatile | {'carrier_H', 'carrier_j', 'carrier_gap', 'expanded', 'mathematical_application'} + need({k: v for k, v in precision.items() if k not in allowed} == + {k: v for k, v in expected.items() if k not in allowed}, 'unchanged raw physical precision census') + text, unchanged = A.closure_source((idir/'check_neutral_closure.py').read_text(), case, funding, proof_sha) + (idir/'check_carrier_closure.py').write_text(text) + if proof_output is not None: + proof_output.mkdir(parents=True, exist_ok=True) + artifacts = {'application.md': proof, + 'precision.patch': ''.join(difflib.unified_diff(original_checker.splitlines(keepends=True), + (pdir/'check_carrier_precision.py').read_text().splitlines(keepends=True), + fromfile='PR5413/check_v16_precision_v3.py', tofile='frontier/check_carrier_precision.py')), + 'conjunction.patch': ''.join(difflib.unified_diff((idir/'check_neutral_closure.py').read_text().splitlines(keepends=True), + text.splitlines(keepends=True), fromfile='PR5413/check_neutral_closure.py', tofile='frontier/check_carrier_closure.py'))} + for suffix, content in artifacts.items(): + target = proof_output/(case['name']+'-'+suffix) + need(not target.exists() or target.read_text() == content, 'review output already differs: '+str(target)) + target.write_text(content) + cman = A.manifest(A.load(idir/'NEUTRAL-CLOSURE-INPUTS-v1.json'), { + 'funding': F.INVOICE+'CARRIER-FUNDING.json', 'precision': F.PRECISION+'CARRIER-PRECISION.json', + 'precision_manifest': F.PRECISION+'CARRIER-SOURCES.json', + 'precision_proof': F.PRECISION+'CARRIER-APPLICATION.md'}, ws) + cman['rows'].append({'id': 'carrier_funding_verifier', 'path': F.INVOICE+'carrier_frontier.py', + 'sha256': A.sha(idir/'carrier_frontier.py')}) + A.dump(idir/'CARRIER-CLOSURE-SOURCES.json', cman) + code, error = A.run_engine(SRC, ws, F.INVOICE+'check_carrier_closure.py', + ['--root', '.', '--manifest', F.INVOICE+'CARRIER-CLOSURE-SOURCES.json', + '--output', F.INVOICE+'CARRIER-CONJUNCTION.json']) + need(code == 0, 'changed-tuple conjunction: '+error[-1800:]) + conjunction = A.load(idir/'CARRIER-CONJUNCTION.json') + need(conjunction['status'] == 'PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION' and + conjunction['premise_count'] == 25 and all(conjunction['premises'].values()), '25 conditional premises') + need(conjunction['assumptions'] == ['native_all_columns', 'owned_erasure', 'compiler', + 'precision_tape', 'analytic_recovery'], 'same five framework assumptions') + controls = {} + if first: + fixed = pdir/'V16-SOURCES-v3.json' + saved = fixed.read_bytes() + try: + fixed.write_bytes(pman_path.read_bytes()) + code, error = A.run_engine(SRC, ws, F.PRECISION+'check_v16_precision_v3.py', + ['--root', '.', '--output', F.PRECISION+'REJECT-ORIGINAL-PRECISION.json']) + finally: + fixed.write_bytes(saved) + controls['original_precision_rejects_changed_carrier'] = code != 0 and 'actual funded carrier rank' in error + code, error = A.run_engine(SRC, ws, F.INVOICE+'check_neutral_closure.py', + ['--root', '.', '--manifest', F.INVOICE+'CARRIER-CLOSURE-SOURCES.json', + '--output', F.INVOICE+'REJECT-ORIGINAL-CONJUNCTION.json']) + controls['original_conjunction_rejects_coarse_tail_application'] = code != 0 and 'closure premise failed' in error + def bad_precision(name, patch): + bad = copy.deepcopy(funding) + patch(bad) + A.dump(idir/(name+'.json'), bad) + altered = A.manifest(pman, {'funding': F.INVOICE+name+'.json'}, ws) + path = pdir/(name+'-SOURCES.json') + A.dump(path, altered) + return precision_run(ws, path, name+'-PRECISION.json') + code, error = bad_precision('previous-grid', lambda x: x.update( + j=x['j']-1, H=F.ceilq(Q(x['j']-1)/Q(x['gap'])))) + controls['preceding_grid_rejected'] = code != 0 and 'actual funded carrier rank' in error + code, error = bad_precision('product-too-large', lambda x: x['tuple'].update(tensor_power=1025)) + controls['unfunded_product_domain_rejected'] = code != 0 and 'compiler product domain' in error + for name, patch in [('missing-paid-job', lambda x: x['paid'].__setitem__('1', x['paid']['1']-1)), + ('free-completion', lambda x: x.update(completion_tail_upper='0'))]: + bad = copy.deepcopy(funding) + patch(bad) + try: + F.verify_funding(ws, bad) + except ValueError: + controls[name+'_rejected_by_complete_rebuild'] = True + else: + controls[name+'_rejected_by_complete_rebuild'] = False + try: + F.certify(ws, dict(case, u=Q(0))) + except ValueError: + controls['invalid_higher_moment_domain_rejected'] = True + controls['coarse_.97_envelope_is_actually_exceeded'] = Q(funding['gamma_upper']) > Q(97, 100) + need(all(controls.values()) and len(controls) == 8, 'semantic rejection controls: '+str(controls)) + return {'case': case['name'], 'funding': funding, + 'application_proof_sha256': proof_sha, 'proof_substitution_sites': len(substitutions), + 'precision': {k: precision[k] for k in ('status', 'carrier_H', 'carrier_j', 'carrier_gap', 'expanded')}, + 'conjunction': {'status': conjunction['status'], 'premise_count': 25, + 'premise_names': sorted(conjunction['premises']), 'unchanged_source_gate_names': unchanged, + 'assumptions': conjunction['assumptions']}, + 'precision_baseline_conservativity': conservativity, 'controls': controls} + + +def build(proof_output=None): + before = input_hashes() + with tempfile.TemporaryDirectory(prefix='carrier-frontier-') as directory: + scratch = Path(directory) + baseline_path = scratch/'BASELINE.json' + run = subprocess.run([sys.executable, '-I', '-B', str(SRC/'verify.py'), + '--output', str(baseline_path)], cwd=ROOT, capture_output=True, timeout=300) + need(run.returncode == 0, 'unmodified PR5413 full replay: '+run.stderr.decode()[-1800:]) + baseline = A.load(baseline_path) + need(baseline['status'] == 'PASS_CONDITIONAL_COMPLETE_NEUTRAL_CALLER_AND_FUNDED_KAPPA' and + len(baseline['runs']) == 8 and all(r['returncode'] == 0 for r in baseline['runs']), 'fresh full caller replay') + base_workspace = Path(baseline['scratch'])/'workspace' + cases = [] + for index, case in enumerate(F.CASES): + ws = scratch/case['name'] + shutil.copytree(base_workspace, ws) + cases.append(case_application(ws, case, index == 0, proof_output)) + shutil.rmtree(ws) + need(input_hashes() == before, 'frozen inputs unchanged during replays') + return {'schema': 'pr5413-carrier-frontier/1', + 'scope': 'Conditional carrier size improvement at fixed or explicitly weaker saving. No raw profile/root improvement, global minimum, practical runtime or unconditional theorem.', + 'fresh_baseline': {'status': baseline['status'], 'engines': [r['name'] for r in baseline['runs']]}, + 'cases': cases, 'source_count': len(before), + 'own_code_sha256': {name: A.sha(HERE/name) for name in ('frontier.py', 'application.py', 'verify.py')}, + 'all_frozen_inputs_unchanged': True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + parser.add_argument('--proof-output', type=Path, help='retain generated proof instances and review diffs outside the package') + args = parser.parse_args() + result = build(args.proof_output) + path = HERE/'RESULT.json' + if args.write: + A.dump(path, result) + need(path.is_file() and A.load(path) == result, 'committed RESULT.json equals complete rebuild') + print('PASS_PR5413_CARRIER_FRONTIER_WITH_CHANGED_TUPLE_PRECISION_AND_CONJUNCTION') + + +if __name__ == '__main__': + main()