From d5893178e0eda61b111fdd48f8807e075c0420f1 Mon Sep 17 00:00:00 2001 From: Figo Lam Date: Wed, 28 Oct 2026 10:50:01 +0000 Subject: [PATCH 1/2] Audit PR6030 deferred-layer uniform recurrence and current stock bound --- research/p104-6030-deferred-layer/PROOF.md | 122 ++++++++++++ research/p104-6030-deferred-layer/README.md | 64 +++++++ research/p104-6030-deferred-layer/REVIEW.md | 43 +++++ .../p104-6030-deferred-layer/SOURCES.json | 84 +++++++++ research/p104-6030-deferred-layer/TASK.json | 91 +++++++++ .../p104-6030-deferred-layer/VALIDATION.md | 25 +++ research/p104-6030-deferred-layer/VERIFY.json | 63 +++++++ .../evidence/overlap.json | 31 +++ .../evidence/registered.txt | 129 +++++++++++++ .../independent_check.py | 102 ++++++++++ research/p104-6030-deferred-layer/verify.py | 176 ++++++++++++++++++ 11 files changed, 930 insertions(+) create mode 100644 research/p104-6030-deferred-layer/PROOF.md create mode 100644 research/p104-6030-deferred-layer/README.md create mode 100644 research/p104-6030-deferred-layer/REVIEW.md create mode 100644 research/p104-6030-deferred-layer/SOURCES.json create mode 100644 research/p104-6030-deferred-layer/TASK.json create mode 100644 research/p104-6030-deferred-layer/VALIDATION.md create mode 100644 research/p104-6030-deferred-layer/VERIFY.json create mode 100644 research/p104-6030-deferred-layer/evidence/overlap.json create mode 100644 research/p104-6030-deferred-layer/evidence/registered.txt create mode 100644 research/p104-6030-deferred-layer/independent_check.py create mode 100644 research/p104-6030-deferred-layer/verify.py diff --git a/research/p104-6030-deferred-layer/PROOF.md b/research/p104-6030-deferred-layer/PROOF.md new file mode 100644 index 0000000000..de725a73e9 --- /dev/null +++ b/research/p104-6030-deferred-layer/PROOF.md @@ -0,0 +1,122 @@ +# The selected uniform tree and deferred stock + +DLamdata, with substantial OpenAI Codex assistance. Apache-2.0. +This is a conditional source-bound specialization, not a new deferred-reservoir method or supplier admission. + +## 1. Sources and the precise implication + +PR6110 at `7f82486e987e556a221085092d8f7aff271ecb35` asks for an audit of PR1673's `SUPPLIER-SUPPORT-AUDIT.md` §6. That older source replaces eager transformation of reserved axes by deferred phases at `K=128G`. The selected manifest binds its `bd5b06...` copy. A later PR1673 `review20261014/REVIEW-RESPONSE.md` §2 already writes the mixed T74 tree and full product-stock argument; its different bytes are an attributed predecessor, not the selected copy. + +More directly, the selected manifest binds `research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md` §5 and `FINITE-TEMPLATE-CLOSURE.md` §§2,5,6. Those sources already give the changed **uniform** supplier, sublinear BIT stock, deferred reservations and per-phase padding deletion. The present result supplies the exact PR6030 substitution and an explicit threshold certificate. It does not discover a missing proof of the generic mechanism. The strong-induction formulation also follows the credited PR4100 audit in `research/complex-stopped-recursion-cost/PROOF.md`; that different supplier is not rerun. + +Hereafter `U` denotes the selected uniform saving (not the historical source's mixed-unit count), `N=2^H` its fixed rank, `W` its productive fields and `P` its paid rank-one calls. The retained compiler contract is + + P/W < N^(1-U). + +All of `N,W,P` are fixed before the eventual input size grows. They are not the raw mixed P104 productive-field count or raw paid-call histogram. At an ordinary width `e=Nf+r`, `0<=r=1`, a root active width `e<=h`, and `s=max(N,h^eta)`. All descendants use this same phase cutoff. Stop when `e<=s`. For integer positive `e`, assume: + +- a leaf costs at most `c_L v e`; +- an internal node's own work, including its fewer than `N` elementary remainder kernels, is at most `c_N Lambda(p) v e^tau`; +- its `P` children have width `floor(e/N)` and volume `v/W`; costs add with the same constants; +- `Lambda(p)>=1` is one fixed polylogarithm, uniform over nodes and phases. + +The internal premise absorbs at most `(N-1)c_L v` remainder work into `c_N`, since `e^tau>=1`. It includes local parking, owned storage, monomial adapters, restoration and actual movement; those are inherited physical obligations, not asserted free. + +Use a weighted-tree potential, independently of the induction used by the separate checker. For an exponent `x>0`, put node mass `v e^x`. Floor contraction implies that its children's total mass is at most `mu_x` times its own. Therefore the total `tau`-mass at depth `j` is at most `mu_tau^j v e^tau`, even after leaves stop. Summing the strict geometric series bounds all internal tolls by + + c_N Lambda(p) v e^tau/(1-mu_tau). + +For the leaf term, replacing an internal frontier node by its children cannot increase total `sigma`-mass, because `mu_sigma<=1`. Repeating this replacement on the finite stopped tree gives leaf mass at most `v e^sigma`. Each leaf has width at most `s`, so `e_leaf <= s^b e_leaf^sigma`. Thus + + T(e,v) <= v [c_N Lambda(p)/(1-mu_tau) e^tau + c_L s^b e^sigma]. (1) + +The tree is finite because every internal child has positive width `floor(e/N)=1`, independent of `h,p`, that covers these constants and complete-chunk rounding. The conservative reservation premise is + + R(h,p) <= 3h/128 + C*(log2 h + h^alpha L^3 + 1). (3) + +An internal-stock implementation can use less. This audit does not numerically materialize `C`; its finiteness and the local stock law remain part of the inherited physical/compiler contract. + +Here is an explicit sufficient threshold, for any additional fixed finite base threshold `M>=1`: + + H0(p) = ceil(max(M, 16, (192C)^2, (192C L^3)^(250/249))). (4) + +For `h>=16`, `log2 h+1<=2 sqrt(h)`. Indeed it holds at 16, and the derivative of `2 sqrt(h)-log2 h-1` is positive there and beyond. For `h>=H0`, therefore, + + C*(log2 h+1) <= h/96, + C*h^(1/250)*L^3 <= h/192. + +The latter is exactly the threshold inequality `h^249 >= (192C L^3)^250`. Hence the excess in (3) is at most `h/64`, and + + R(h,p) <= 5h/128 < h/16. (5) + +The degree of this explicit tail bound is `750/249=250/83` in `L`. All fixed constants, including those of the enormous uniform word, affect its coefficient and `M`. This is not a practical or numerically emitted PR6030 cutoff. + +## 5. Completed layer and the removed hypothesis + +At phase width `h`, expose complete selected neighborhoods in the **global complete tensor**, reserve `R` chunks, execute the ordinary active call, and return every reserved/spectator coordinate unchanged. Do not first transform reserved selected bits. The next phase acts only on those `R` selected bits. Exposure and restoration cost `O(V Lambda(p) h^tau)` under the retained support router. + +One phase pads its row count by a factor below two. Its complete endpoint is identity on the row coordinate, so appended zero rows return to zero and can be deleted **before** inverse placement and the next phase. Thus each phase volume is below `2V`; it is not `2^j V` at phase `j`. Exact return is an explicit premise: this argument does not authorize dropping rounded nonzero rows or clear residual errors for free. + +Above (4), successive widths obey `h_(j+1)<=h_j/16`. With `l=lambda_prime>1/2`, + + sum_j h_j^l <= g^l/(1-16^(-l)) <= (4/3) g^l. + +By (2), `tau=1`, all active-phase work, padding and exposure sum to `O(V Lambda(p) g^(1-q))`. The remaining at most `H0(p)` selected bits cost `O(V H0(p) polylog p)` elementarily. Since `g>=1` and (4) is polylogarithmic, the full result is + + T_layer(g,V,p) = O(V g^(1-q) polylog p), 1<=g<=p, under the stated contracts. (6) + +The cost implication is uniform over those roots **when the complete-layout and router premises hold**. It does not construct geometric support for every `g<=p`: the selected caller uses polynomially sublinear `g=Theta(p^beta)` with `beta=1` and fixed finite base threshold `M`, a sufficient tail threshold is + + `ceil(max(M,16,(192C)^2,(192C L^3)^(250/249)))`. + + Above it, `R<=5h/128b, 'uniform moment gap') + need(H*(u-b)==47005, 'current compiled-moment bound') + return dict(sigma=sigma,tau=tau,target=target,leaf=leaf, + tau_minus_sigma=tau-sigma,tau_minus_leaf=tau-leaf, + target_minus_tau=target-tau,target_minus_leaf=target-leaf, + uniform_minus_b=u-b,moment_power=H*(u-b)) + +s=selected_checks(p,r['complete_cost']['compiler']['H']) +need(p['lambda_prime']==s['target'], 'record target agrees') +need(F(r['complete_cost']['ordinary_BIT']['atom'])==F(1,250),'current atom') +controls=0 +for changes in ({'complex_uniform_saving':p['b']},{'q':p['a']},{'stop':F(1)}): + bad=dict(p,**changes) + try: selected_checks(bad,r['complete_cost']['compiler']['H']) + except ValueError: controls+=1 + else: raise ValueError('failed rejection control') + +# Exact separate toy recurrence, m=16, P/W=2, sigma=1/2, tau=3/4. +# It has moment 1/2 at sigma and 1/4 at tau. Node work includes every remainder. +def fourth_floor(n): + return isqrt(isqrt(n)) +def cutoff(h): + t=fourth_floor(h) + return max(16,t+(t**432: + reserve=h//16 + active=h-reserve + total+=2*(cost(h,active)+fourth_floor(h**3)+1) + processed+=active + h=reserve + total+=h + processed+=h + need(processed==g,'selected-axis partition') + need(total<=55*fourth_floor(g**3),'toy deferred envelope') + phase_cases+=1 + +# A genuine bad alternative: eager treatment of floor(g/32) reserved axes. +# At g=16^k its ratio to g^(3/4) grows as 2^k/32 (for k>=2). +eager=[] +for k in range(2,11): + g=16**k + ratio=F(g//32,8**k) + need(ratio==F(2**k,32),'eager linear cost ratio') + eager.append(str(ratio)) + +print(json.dumps({'source_sha256':hashlib.sha256(raw).hexdigest(), + 'selected_exact':{k:str(v) for k,v in s.items()}, + 'selected_rejections':controls, + 'stopped_toy_cases':len(widths),'deferred_toy_cases':phase_cases, + 'eager_cost_ratios':eager},indent=2)) +print('PASS_INDEPENDENT_DEFERRED_RECURRENCE') diff --git a/research/p104-6030-deferred-layer/verify.py b/research/p104-6030-deferred-layer/verify.py new file mode 100644 index 0000000000..a98f2d998b --- /dev/null +++ b/research/p104-6030-deferred-layer/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Source-bound exact PR6030 specialization; DLamdata with Codex, Apache-2.0. + +No source implementation is imported. Infinite claims are proved in PROOF.md; +these checks certify source bindings, rational substitutions and finite controls. +""" +from fractions import Fraction as F +from pathlib import Path +import hashlib +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +RESULT = 'research/p104-helper470-twin-rung-removal/RESULT.json' +MANIFEST = 'certificates/frontier6030-source.json' +SELECTED_SOURCES = ( + RESULT, + 'research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md', + 'research/kappa-rebuild/transfer-audit/FINITE-TEMPLATE-CLOSURE.md', + 'research/kappa-rebuild/transfer-audit/OUTER-TRANSFER-AUDIT.md', + 'research/kappa-observation-integration/release-work/current/package/vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md', + 'notes/batched-complex-rows.tex', + 'research/query-thinned-controllers/PROOF.md', +) + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def reject(fn, label): + try: + fn() + except ValueError: + return label + raise ValueError('control accepted: ' + label) + + +def certify(p, H, atom): + U,b,a,q,eta = (p[k] for k in ('complex_uniform_saving','b','a','q','stop')) + sigma,tau,l = 1-b,1-a,1-q + gamma = sigma+eta*b + require(0 < sigma < tau < l < 1, 'internal order') + require(F(1,2) < l, 'phase bound uses l>1/2') + require(0 < eta < 1 and gamma < tau, 'leaf order') + require(U>b and H>0, 'compiler gap') + require(0 < atom < F(1,2), 'stock exponent range for log cubed bound') + require(atom==F(1,250), 'current atom binding') + require(p['lambda_prime']==l, 'lambda prime binding') + out = { + 'sigma_moment_negative_binary_exponent': H*(U-b), + 'tau_moment_negative_binary_exponent': H*(U-a), + 'tau_minus_sigma': tau-sigma, + 'lambda_prime_minus_tau': l-tau, + 'tau_minus_leaf': tau-gamma, + 'lambda_prime_minus_leaf': l-gamma, + 'stock_threshold_power': 1/(1-atom), + 'stock_threshold_log_degree': 3/(1-atom), + } + require(out['sigma_moment_negative_binary_exponent']==47005, 'sigma source exponent') + require(out['tau_moment_negative_binary_exponent']==94010, 'tau source exponent') + return out + + +def threshold_exponent(C,L,M): + """2^t is a safe integer upper envelope of PROOF (4), no float roots.""" + require(all(isinstance(x,int) and x>=1 for x in (C,L,M)), 'threshold domain') + k=(192*C*L**3).bit_length() + return max(4,M.bit_length(),2*(192*C).bit_length(),(250*k+248)//249) + + +def threshold_witness(C,L,M,h): + require(h>=max(16,M,(192*C)**2), 'logarithmic/base reserve budget') + require(h**249 >= (192*C*L**3)**250, 'current stock reserve budget') + + +def main(): + sources=json.loads((HERE/'SOURCES.json').read_text(encoding='utf-8')) + pins={x['path']:x for x in sources['files']} + count=0 + for row in sources['files']: + if row['usage']=='input': + raw=(ROOT/row['path']).read_bytes() + require(hashlib.sha256(raw).hexdigest()==row['sha256'], 'source hash: '+row['path']) + count+=1 + manifest=json.loads((ROOT/MANIFEST).read_text(encoding='utf-8'))['files'] + for path in SELECTED_SOURCES: + require(manifest.get(path)==pins[path]['sha256'], 'selected manifest binding: '+path) + raw=json.loads((ROOT/RESULT).read_text(encoding='utf-8'))['complete_cost'] + p={k:F(v) for k,v in raw['outer']['parameters'].items()} + H=raw['compiler']['H'];atom=F(raw['ordinary_BIT']['atom']) + require(raw['compiler']['N']==f'2^{H}', 'compressed rank binding') + require(F(raw['compiler']['uniform_saving'])==p['complex_uniform_saving'], 'compiler saving binding') + require(raw['compiler']['word_materialized'] is False, 'materialization status') + exact=certify(p,H,atom) + require(exact['tau_minus_leaf']==F(6978119347,9800000000000000000), 'leaf certificate') + require(exact['lambda_prime_minus_leaf']==F(13978119347,9800000000000000000), 'target certificate') + # Bind the precise selected legacy-to-uniform contract, not just filenames. + fragments={ + SELECTED_SOURCES[1]: ['Every rank-one leaf becomes the ordinary rank-`f` child.'], + SELECTED_SOURCES[2]: ['P < W*N^z','exactly `1/W` of its parent','Pad complete rows once'], + SELECTED_SOURCES[3]: ['q0(h,p) <= C*(log2 h + h^0.003*(log2 p)^3 + 1)', 'prevents an accumulating factor of two per phase'], + SELECTED_SOURCES[4]: ['do not first apply C','K=128G does not satisfy that literal condition'], + SELECTED_SOURCES[5]: ['1-c,0','W^{-j}'], + SELECTED_SOURCES[6]: ['Change the atom power to delta=0.004','digits remain O(w log e)=o(e)'], + } + for path, words in fragments.items(): + text=(ROOT/path).read_text(encoding='utf-8') + for word in words:require(word in text, 'source statement: '+word) + controls=[] + for key,value,name in [ + ('complex_uniform_saving',p['b'],'closed uniform gap'), + ('q',p['a'],'closed internal margin'), + ('stop',F(1),'linear leaf cost'), + ('stop',F(0),'invalid stopping endpoint'), + ]: + controls.append(reject(lambda k=key,v=value:certify(dict(p,**{k:v}),H,atom),name)) + controls.append(reject(lambda:certify(p,H-1,atom),'changed rank exponent')) + controls.append(reject(lambda:certify(p,H,F(3,1000)),'stale BIT atom')) + controls.append(reject(lambda:certify(p,H,F(1)),'linear stock')) + witnesses=[] + for C in (1,2,17,1000): + for L in (1,2,20,100): + for M in (1,16,10**6): + t=threshold_exponent(C,L,M);h=1< Date: Wed, 28 Oct 2026 10:50:39 +0000 Subject: [PATCH 2/2] Retain committed-byte and read-only export verification receipts --- .../p104-6030-deferred-layer/VALIDATION.md | 14 +- .../evidence/committed-bytes.txt | 1 + .../evidence/export.txt | 2 + .../evidence/portable.json | 31 +++++ .../evidence/portable.txt | 127 ++++++++++++++++++ 5 files changed, 174 insertions(+), 1 deletion(-) create mode 100644 research/p104-6030-deferred-layer/evidence/committed-bytes.txt create mode 100644 research/p104-6030-deferred-layer/evidence/export.txt create mode 100644 research/p104-6030-deferred-layer/evidence/portable.json create mode 100644 research/p104-6030-deferred-layer/evidence/portable.txt diff --git a/research/p104-6030-deferred-layer/VALIDATION.md b/research/p104-6030-deferred-layer/VALIDATION.md index 82501ebf80..463f91e13e 100644 --- a/research/p104-6030-deferred-layer/VALIDATION.md +++ b/research/p104-6030-deferred-layer/VALIDATION.md @@ -18,7 +18,19 @@ An initial metadata invocation rejected the nonstandard outcome string; it was c ## Publication checks -Committed-byte, source-history, export/integrity and read-only Git-free replay receipts are added below after execution. Export is a transport/dependency check, not mathematical certification. Final commit/status details also appear in the contribution PR. +At scientific commit `d5893178e0eda61b111fdd48f8807e075c0420f1`, these commands passed: + +```sh +python -B scripts/check_research_commit.py --package research/p104-6030-deferred-layer --check-source-history +python -B scripts/export_research_package.py export --package research/p104-6030-deferred-layer --ref d5893178e0eda61b111fdd48f8807e075c0420f1 --output /tmp/reviewed-package.tar +python -B scripts/export_research_package.py check /tmp/reviewed-package.tar +``` + +The output archive location is incidental; a fresh path is required. Actual receipts: [committed-bytes.txt](evidence/committed-bytes.txt) and [export.txt](evidence/export.txt). The byte preflight checks 22 package/input files and ancestry of the exact scientific base. The export/integrity checks pass the same 22 files. + +The checked archive was extracted into a fresh directory. Every file was set read-only, directories nonwritable, PATH was empty, and the working directory was unrelated to the export. Both direct verifiers ran with absolute paths, `-I -B`, normally and with `-O`; all four passed on CPython 3.12.14. SHA256 of every exported file, including the export receipt, was unchanged afterward. See [portable.json](evidence/portable.json) and [actual outputs](evidence/portable.txt). + +These receipts are added in a following evidence-only commit. Final committed-byte/source-history and fresh export/direct replay checks are repeated at the publication head and recorded in the PR; the scientific proof and both checkers are unchanged. Export is a transport/dependency check, not mathematical certification. ## Checks deliberately not run diff --git a/research/p104-6030-deferred-layer/evidence/committed-bytes.txt b/research/p104-6030-deferred-layer/evidence/committed-bytes.txt new file mode 100644 index 0000000000..0ca4ed2c6c --- /dev/null +++ b/research/p104-6030-deferred-layer/evidence/committed-bytes.txt @@ -0,0 +1 @@ +PASS_RESEARCH_COMMIT_BYTES {"commit": "d5893178e0eda61b111fdd48f8807e075c0420f1", "files": 22, "package": "research/p104-6030-deferred-layer", "source_history_commits": ["721c03822c421b7f7fcbb2598993b947c4d88419"]} diff --git a/research/p104-6030-deferred-layer/evidence/export.txt b/research/p104-6030-deferred-layer/evidence/export.txt new file mode 100644 index 0000000000..5a5a2b45f2 --- /dev/null +++ b/research/p104-6030-deferred-layer/evidence/export.txt @@ -0,0 +1,2 @@ +PASS_RESEARCH_EXPORT {"commit": "d5893178e0eda61b111fdd48f8807e075c0420f1", "package": "research/p104-6030-deferred-layer", "files": 22} +PASS_RESEARCH_EXPORT {"commit": "d5893178e0eda61b111fdd48f8807e075c0420f1", "package": "research/p104-6030-deferred-layer", "files": 22} diff --git a/research/p104-6030-deferred-layer/evidence/portable.json b/research/p104-6030-deferred-layer/evidence/portable.json new file mode 100644 index 0000000000..43c08ed9b5 --- /dev/null +++ b/research/p104-6030-deferred-layer/evidence/portable.json @@ -0,0 +1,31 @@ +{ + "status": "PASS_READONLY_GITFREE_EXPORT", + "python": "3.12.14", + "PATH": "empty", + "working_directory": "unrelated directory", + "read_only": true, + "exported_files_including_receipt": 23, + "content_unchanged": true, + "checks": [ + { + "script": "verify.py", + "optimized": false, + "exit_code": 0 + }, + { + "script": "verify.py", + "optimized": true, + "exit_code": 0 + }, + { + "script": "independent_check.py", + "optimized": false, + "exit_code": 0 + }, + { + "script": "independent_check.py", + "optimized": true, + "exit_code": 0 + } + ] +} diff --git a/research/p104-6030-deferred-layer/evidence/portable.txt b/research/p104-6030-deferred-layer/evidence/portable.txt new file mode 100644 index 0000000000..919eb8b8aa --- /dev/null +++ b/research/p104-6030-deferred-layer/evidence/portable.txt @@ -0,0 +1,127 @@ +{ + "exact": { + "lambda_prime_minus_leaf": "13978119347/9800000000000000000", + "lambda_prime_minus_tau": "1/1400000000", + "sigma_moment_negative_binary_exponent": "47005", + "stock_threshold_log_degree": "250/83", + "stock_threshold_power": "250/249", + "tau_minus_leaf": "6978119347/9800000000000000000", + "tau_minus_sigma": "1/1400000000", + "tau_moment_negative_binary_exponent": "94010" + }, + "padding_fixtures": 528, + "rejected_controls": [ + "closed uniform gap", + "closed internal margin", + "linear leaf cost", + "invalid stopping endpoint", + "changed rank exponent", + "stale BIT atom", + "linear stock", + "insufficient stock threshold", + "missing finite base threshold", + "ceiling violates uniform potential", + "padding retained across phases", + "nonidentity row endpoint" + ], + "scope": "Conditional source-bound cost specialization; no physical or compiler admission.", + "selected_manifest_bindings": 7, + "source_inputs": 11, + "status": "PASS_PR6030_DEFERRED_LAYER", + "threshold_fixtures": 48 +} + +{ + "exact": { + "lambda_prime_minus_leaf": "13978119347/9800000000000000000", + "lambda_prime_minus_tau": "1/1400000000", + "sigma_moment_negative_binary_exponent": "47005", + "stock_threshold_log_degree": "250/83", + "stock_threshold_power": "250/249", + "tau_minus_leaf": "6978119347/9800000000000000000", + "tau_minus_sigma": "1/1400000000", + "tau_moment_negative_binary_exponent": "94010" + }, + "padding_fixtures": 528, + "rejected_controls": [ + "closed uniform gap", + "closed internal margin", + "linear leaf cost", + "invalid stopping endpoint", + "changed rank exponent", + "stale BIT atom", + "linear stock", + "insufficient stock threshold", + "missing finite base threshold", + "ceiling violates uniform potential", + "padding retained across phases", + "nonidentity row endpoint" + ], + "scope": "Conditional source-bound cost specialization; no physical or compiler admission.", + "selected_manifest_bindings": 7, + "source_inputs": 11, + "status": "PASS_PR6030_DEFERRED_LAYER", + "threshold_fixtures": 48 +} + +{ + "source_sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad", + "selected_exact": { + "sigma": "6978119347/7000000000", + "tau": "872264919/875000000", + "target": "6978119357/7000000000", + "leaf": "9769367085821880653/9800000000000000000", + "tau_minus_sigma": "1/1400000000", + "tau_minus_leaf": "6978119347/9800000000000000000", + "target_minus_tau": "1/1400000000", + "target_minus_leaf": "13978119347/9800000000000000000", + "uniform_minus_b": "1/1400000000", + "moment_power": "47005" + }, + "selected_rejections": 3, + "stopped_toy_cases": 4152, + "deferred_toy_cases": 255, + "eager_cost_ratios": [ + "1/8", + "1/4", + "1/2", + "1", + "2", + "4", + "8", + "16", + "32" + ] +} +PASS_INDEPENDENT_DEFERRED_RECURRENCE + +{ + "source_sha256": "84fcbe2a0b64307b5703c363408042bdd91555b0419509aa50daa43b3b1924ad", + "selected_exact": { + "sigma": "6978119347/7000000000", + "tau": "872264919/875000000", + "target": "6978119357/7000000000", + "leaf": "9769367085821880653/9800000000000000000", + "tau_minus_sigma": "1/1400000000", + "tau_minus_leaf": "6978119347/9800000000000000000", + "target_minus_tau": "1/1400000000", + "target_minus_leaf": "13978119347/9800000000000000000", + "uniform_minus_b": "1/1400000000", + "moment_power": "47005" + }, + "selected_rejections": 3, + "stopped_toy_cases": 4152, + "deferred_toy_cases": 255, + "eager_cost_ratios": [ + "1/8", + "1/4", + "1/2", + "1", + "2", + "4", + "8", + "16", + "32" + ] +} +PASS_INDEPENDENT_DEFERRED_RECURRENCE