diff --git a/research/staged-donor-release/CONCURRENT-WORK.md b/research/staged-donor-release/CONCURRENT-WORK.md new file mode 100644 index 0000000000..4805da1b34 --- /dev/null +++ b/research/staged-donor-release/CONCURRENT-WORK.md @@ -0,0 +1,34 @@ +# Concurrent work found at the final checkpoint + +The final complete overlap refresh (374 open PR bodies and 2464 Discussion +records, zero pagination warnings, 2026-10-18 13:33 UTC) found concurrent work +not returned by the earlier narrower literal-term queries. No priority claim +is made. Canonical main remains 20ecf2891d80b5acf18d980b2164fb44ea7faa90. + +- [PR3642](https://github.com/CrocSwap/integer-mult-bounds/pull/3642), current + head 044d24f12e74f228dd462c07ae2d7f3ea35e2be9, created 12:30 UTC, + reports the same two commuting release retimings with a T530 allocation. + Its current conditional endpoint is .001730394391813963415120 minus the + same backoffs. Its retiming contribution deserves explicit credit. +- [PR3653](https://github.com/CrocSwap/integer-mult-bounds/pull/3653), current + head 607a09ff441c79b215a8127a81f4cc70021d0d9b, created 13:08:59 UTC, + composes those suppliers with T488 and reports exactly this package's + conditional endpoint .001730418899766071163804−10^-46−10^-70. + Its declared counts satisfy h488/488=h360/360 for every rank; cross-products + were checked exactly. We have not independently replayed its release. + +This T360 package thus **matches the concurrently reported retimed endpoint +with smaller stock**: 323069 instead of 437757 physical families, 3240 instead +of 4392 calls, and 1321920 instead of 1791936 literal helper roles. That stock +reduction changes finite constants, not the normalized exponent. Its exact +local construction and conditional finite release remain a strict improvement +over the explicitly pinned PR3638/PR3633 predecessor. It is not a further +frontier increase over PR3653. No new selected-frontier value is asserted. + +The local result was independently investigated during this campaign, but the +final draft is framed as T360 composition plus independent source/evidence +checks, with the concurrent mechanism and endpoint credited. Frozen scientific +receipts, comparator pins and the original review at a3bdc591 are preserved. +The public PR bodies/head/timestamps read at this checkpoint are retained under +evidence/concurrent. They are provisional external evidence, not scientific +admission. None of these PRs was altered, reviewed wholesale or closed here. diff --git a/research/staged-donor-release/LEAD1-CONTROLS.json b/research/staged-donor-release/LEAD1-CONTROLS.json new file mode 100644 index 0000000000..500dfb67d1 --- /dev/null +++ b/research/staged-donor-release/LEAD1-CONTROLS.json @@ -0,0 +1,76 @@ +{ + "status": "PASS_SOURCE_BOUND_ENDPOINT_CONTROLS", + "transport_sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "checks": [ + { + "provider": "base", + "control": "valid", + "exit_code": 0, + "endpoint_rejected": false, + "log_sha256": "912da5c69252a47dd82b3dd02a75f69519de43d05ce37fd63dc455315e295b7f" + }, + { + "provider": "base", + "control": "omit-release-644", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "fe440dff56d88ffb1254befeb9b4d0034da4e471e63f93c0a0eaf1b472ae7b70" + }, + { + "provider": "base", + "control": "wrong-sign-644", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "fe440dff56d88ffb1254befeb9b4d0034da4e471e63f93c0a0eaf1b472ae7b70" + }, + { + "provider": "base", + "control": "omit-release-660", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "7415a2086c69858488094fc3102766a0c3f53ecd637852ac5f0612ff3a6960aa" + }, + { + "provider": "base", + "control": "wrong-sign-660", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "7415a2086c69858488094fc3102766a0c3f53ecd637852ac5f0612ff3a6960aa" + }, + { + "provider": "extra", + "control": "valid", + "exit_code": 0, + "endpoint_rejected": false, + "log_sha256": "08199ef6bbb9959ae9de501a2bf8c4c0c8c3291334f8ec2e05e6e688ed04ef7a" + }, + { + "provider": "extra", + "control": "omit-release-644", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "fe440dff56d88ffb1254befeb9b4d0034da4e471e63f93c0a0eaf1b472ae7b70" + }, + { + "provider": "extra", + "control": "wrong-sign-644", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "fe440dff56d88ffb1254befeb9b4d0034da4e471e63f93c0a0eaf1b472ae7b70" + }, + { + "provider": "extra", + "control": "omit-release-660", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "7415a2086c69858488094fc3102766a0c3f53ecd637852ac5f0612ff3a6960aa" + }, + { + "provider": "extra", + "control": "wrong-sign-660", + "exit_code": 1, + "endpoint_rejected": true, + "log_sha256": "7415a2086c69858488094fc3102766a0c3f53ecd637852ac5f0612ff3a6960aa" + } + ] +} diff --git a/research/staged-donor-release/LEAD1-PRICE.json b/research/staged-donor-release/LEAD1-PRICE.json new file mode 100644 index 0000000000..ae417c0ec5 --- /dev/null +++ b/research/staged-donor-release/LEAD1-PRICE.json @@ -0,0 +1,36 @@ +{ + "dual": { + "patterns": 2551, + "symbolic_tight": 12, + "minimum_strict_lower": "4053468025645212954130191300621690725601209608148213926713/1000000000000000000000000000000000000000000000000000000000000", + "scope": "Old capacity and pattern alphabet, evaluated at stated K; not a dual for arbitrary changed widths." + }, + "status": "PASS_EXACT_LOCAL_AND_FIXED_ALLOCATION_PRICE", + "k": "173009636352862353423/100000000000000000000000", + "local_delta": { + "lower": "-3299714488759840734997518419826012212910695186919289400037/500000000000000000000000000000000000000000000000000000000000", + "upper": "-6599428977519681469995036839652024425821390373838578800073/1000000000000000000000000000000000000000000000000000000000000" + }, + "width8_to7_shadow_times20": { + "lower": "246935045936431659522948237548685897943499745459984726817273/12500000000000000000000000000000000000000000000000000000000", + "upper": "19754803674914532761835859003894871835479979636798778145381841/1000000000000000000000000000000000000000000000000000000000000" + }, + "prior_staged_net_times10": { + "lower": "-65268039542568976533836655295640969913942214558880321551831/1000000000000000000000000000000000000000000000000000000000000", + "upper": "-6526803954256897653383665529564096991394221455888032155183/100000000000000000000000000000000000000000000000000000000000" + }, + "profile": { + "1": 7980120, + "2": 2345760, + "3": 755730, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "root_interval": [ + "0.001730418899766071163804", + "0.001730418899766071163805" + ], + "scope": "Exact finite paid profile using unchanged T360 idle and private stock. No native, physical ordinary/outer admission follows from these inequalities." +} diff --git a/research/staged-donor-release/PR-DRAFT.md b/research/staged-donor-release/PR-DRAFT.md new file mode 100644 index 0000000000..c4fb02047a --- /dev/null +++ b/research/staged-donor-release/PR-DRAFT.md @@ -0,0 +1,51 @@ +# Consume retimed staged releases with smaller T360 stock + +## Change and mathematical scope + +Compose the two commuting staged-release retimings with the literal T360 allocation. The complete conditional finite release supports **κ = 0.001730418899766071163804 − 10^-46 − 10^-70**, matching the endpoint reported by [PR3653](https://github.com/CrocSwap/integer-mult-bounds/pull/3653) with **323,069 instead of 437,757 physical families**, 3,240 instead of 4,392 calls, and 1,321,920 instead of 1,791,936 helper roles. The normalized profiles are identical; smaller stock changes finite constants. No priority or further frontier gain over PR3653 is claimed. + +In PR3605's words, move `640 += 2*644` and `656 -= 660` to immediately before the pivots' first producer updates. Exact commutation preserves the full arbitrary-dirty operator, while each donor pays H3 instead of H1+H2. Both providers have local profile `{1:2437,2:724,3:226,4:102,5:20,8:8}`. The complete paid profile is `{1:7980120,2:2345760,3:755730,4:330480,5:69930,8:25920,48:137790}` across 322,560 live families, with 509 additional private families. The invoice includes both providers, all literal roles, 91 zero buffers, and the charged 2,048-bit prefix reserve. + +All-size/compiler, uniform source/hosting, recursive precision/tape/recovery, bootstrap, analytic and BIT hypotheses remain inherited. This is a conditional finite construction, not an unconditional multiplication theorem or a selected-frontier update. + +## Task and overlap + +Explicitly assigned staged-release consumer work; task `independent-moment`, **changed scope**: change and fully price an actual word, rather than only audit an unchanged moment. See `research/staged-donor-release/TASK.json` for the original card and scope rationale. + +Base: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. Exact predecessor inputs are retained with source hashes and notices: + +- PR3605 staged words: `3efbb5de06a49ffeea6684482f2d3fe48cdca3fb`. +- PR3638 T360 allocation: `d62e1acd7518a231440383f0d0dddf54d6edf8c1`. +- PR3633 packing comparison: `72c268f113368ea0387d188225e3f81ba6d6ef73`. + +Concurrent [PR3642](https://github.com/CrocSwap/integer-mult-bounds/pull/3642) reports the same retiming mechanism; PR3653 composes it with T488. This independently constructed package contributes the smaller T360 consumer and its source-bound validation. The strict gain of `0.000000322536237447629574` is relative only to the pinned PR3638/PR3633 predecessor on the common release grid. The final full overlap search covered 374 open PR bodies and 2,464 Discussion records; the related PR heads were rechecked during preparation. Coverage is not a novelty proof. See `CONCURRENT-WORK.md` for exact heads and comparisons. + +## Validation + +- Both changed providers passed fresh five-stage native replay: 632 arbitrary columns in both orientations, phase/warp recipes, and actual omission/sign controls. +- The complete original release passed all strict finite margins, with the predecessor edit chain retained and a separately checked retiming stage. The original run explicitly reused authenticated unchanged native/parent evidence and preparatory discovery after a declared-stage binding repair. +- Exact dual calibration, integral T360 fill, independent frame/invoice checks, and owner-transfer/source-closure checks passed. Fresh Astra medium review approved the scoped scientific result at `a3bdc591920a4b9003d8442d1fcca24218153661`; a follow-up review approved the concurrent-work framing. These are independent AI reviews, not human or formal-kernel approval. +- Bounded registered replay, committed-byte comparison and Git-free committed export replay pass for the prepared package. The new full-wrapper evidence is separate from the frozen original scientific evidence. + +Reproduce the bounded package with Python 3.12 (standard library only): + +```sh +python3.12 -B scripts/research_package.py --package research/staged-donor-release --check-only +python3.12 -B scripts/research_package.py --package research/staged-donor-release +``` + +Full replay: Python 3.12.8, NumPy 1.26.4, SciPy 1.15.3, SymPy 1.14.0, mpmath 1.3.0; assertions enabled, one heavy replay at a time: + +```sh +python3.12 -B research/staged-donor-release/full_replay.py --work /tmp/fresh-staged-release +``` + +The default full wrapper **passed end to end**, including both fresh changed native providers, fresh preparation and all seven complete-admission stages. The wrapper and scientific inputs match commit `74afc9ff5cb437d3112c6279216d10250775cd98` and are unchanged in this preparation update. Raw receipts, logs, environment versions and hashes are retained in `research/staged-donor-release/evidence/full-wrapper/`; the bounded verifier authenticates them and rejects four targeted receipt inconsistencies. This later run retains explicitly authenticated unchanged parent/native ancestry; it is execution evidence subsequent to the cited independent AI review. A no-reuse retained-parent cold run and hosted CI have not been run. Source-history preflight refused the shallow checkout; the self-contained archive instead reconstructs all required source bytes without foreign Git objects. No Lean or Docker was run. + +## Credit + +Credit Ross Richardson/PR3605, roger-sato's concurrent PR3642, Rohan Arun's PR3653, Pierre-Loic Doulcet's PR3633, PR3638's T360 allocation, dcharb78/PR3133, Marius-Paul Dumitrean/PR2979, Jeremy Kothe, and the retained native, owner, block-norm and outer authors. Exact source notices remain in the package. Apache-2.0; substantial OpenAI Codex assistance and independent AI review. + +## Open next questions + +See the package README and structured `TASK.json` questions. A useful next construction would identify one compensated later release or changed joint consumer, prove its arbitrary-dirty identity, and price its complete invoice before synthesis. The inherited uniform/all-size premises remain separate open obligations. diff --git a/research/staged-donor-release/PROOF.md b/research/staged-donor-release/PROOF.md new file mode 100644 index 0000000000..a9da712a7d --- /dev/null +++ b/research/staged-donor-release/PROOF.md @@ -0,0 +1,104 @@ +# Lead 1: delayed donor release on the staged words + +LOCAL-ONLY complete conditional finite release; independent terminal approval recorded at a3bdc591920a4b9003d8442d1fcca24218153661. No selected-frontier change. + +The changed producer neighborhood is helper644/donor640 and its symmetric +helper660/donor656. Unlike another endpoint extraction on PR3133, the input +is PR3605's actual staged word, authenticated by the compressed pins in +SOURCE-PINS.json. Move B591 `640 += 2*644` to just before old B1045; +move B641 `656 -= 660` to just before old B1085. The other delayed releases +(into496/520) stay at their staged positions. Every warp table entry retains +its original identity; only its B cut is reindexed. Frames and source symbols +of every other instruction are retained; full inverse cleanup is regenerated. + +Between each old/new cut the pivot is never written, the donor is never read, +and neither crosses a native warp. Thus every intervening elementary matrix +commutes with the release shear. The complete operator is exactly unchanged +on arbitrary independent dirty states, including both inverse-transpose words. +The same prefix/suffix product equality preserves all632 inputs and91 private +zero buffers. Native replay independently checks every column in both +orientations and both providers. Omit/sign mutants regenerate cleanup and +must fail the actual endpoint, not merely a declared record comparison. + +The late release uses the pivot's first producer frame (rank4). Its donor now +jumps directly from its rank1 entrance to rank4 rather than through rank2. +Per donor delta is H3-H2-H1. For0idx:rec[0]-=1 + y['cleanup']=cleanup(y) + word=t/f'{provider}-{name}.json.gz';word.write_bytes(gzip.compress(json.dumps(y,separators=(',',':')).encode(),mtime=0));out=t/f'{provider}-{name}' + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1');env.pop('PYTHONOPTIMIZE',None) + r=subprocess.run([sys.executable,'-B',str(a.transport.resolve()),str(word),str(out)],env=env,stdout=subprocess.PIPE,stderr=subprocess.STDOUT) + text=r.stdout.decode();assert (r.returncode==0)==(name=='valid'),(name,text) + if name!='valid':assert 'arbitrary-input endpoint' in text,(name,text) + rows.append(dict(provider=provider,control=name,exit_code=r.returncode,endpoint_rejected=name!='valid',log_sha256=hashlib.sha256(r.stdout).hexdigest())) + print(json.dumps(dict(status='PASS_SOURCE_BOUND_ENDPOINT_CONTROLS',transport_sha256=hashlib.sha256(a.transport.read_bytes()).hexdigest(),checks=rows),indent=2)) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/delay_release.py b/research/staged-donor-release/delay_release.py new file mode 100644 index 0000000000..2f23aae585 --- /dev/null +++ b/research/staged-donor-release/delay_release.py @@ -0,0 +1,39 @@ +"""Commute two releases to their first producer, preserving all other frames.""" +import copy,gzip,json +from pathlib import Path +from collections import Counter +from invoice import profile +from sources.staged_pair import cleanup +P=Path(__file__).parent + +def build(w): + x=copy.deepcopy(w);at={} + for j,rec in enumerate(w['warps']):at.setdefault(rec[0],[]).append((j,copy.deepcopy(rec))) + moves={} + for h,d,q in [(644,640,2),(660,656,-1)]: + start=next(i for i,g in enumerate(w['B']) if g[:5]==['add',d,h,q,1]) + stop=next(i for i in range(start+1,len(w['B'])) if w['B'][i][1]==h) + for i in range(start+1,stop): + g=w['B'][i] + if g[0]=='add':assert g[1]!=h and g[2]!=d + else:assert g[1] not in (h,d) + assert all(r[1][1] not in (h,d) for r in at.get(i,[])) + assert all(r[1][1] not in (h,d) for r in at.get(stop,[])) + moves[start]=(stop,['add',d,h,q,1,w['B'][stop][-1]]) + b=[];warps=[None]*len(w['warps']) + for i in range(len(w['B'])+1): + for j,rec in at.get(i,[]):rec[0]=len(b);warps[j]=rec + for stop,g in moves.values(): + if i==stop:b.append(copy.deepcopy(g)) + if i0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "0bc39b4bc037bde6b1644cc53bcf9394e585e0d8245c48b2cfdb79365e216ffc", + "before_sha256": "8e1c5b5c4291637aa0ed4366792106df3cd7110bdfcc117a3d5da30a8f209862", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 + main() + File "/tmp/four-kappa-release-inputs/admit.py", line 344, in main + archive.extractall(layout, filter='data') + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 2302, in extractall + self._extract_one(tarinfo, path, set_attrs=not tarinfo.isdir(), + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 2369, in _extract_one + self._handle_fatal_error(e) + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 2365, in _extract_one + self._extract_member(tarinfo, os.path.join(path, tarinfo.name), + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 2448, in _extract_member + self.makefile(tarinfo, targetpath) + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 2502, in makefile + copyfileobj(source, target, tarinfo.size, ReadError, bufsize) + File "/opt/local/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/tarfile.py", line 254, in copyfileobj + dst.write(buf) +OSError: [Errno 28] No space left on device diff --git a/research/staged-donor-release/evidence/diagnostics/first-builder-endpoint-failure.txt b/research/staged-donor-release/evidence/diagnostics/first-builder-endpoint-failure.txt new file mode 100644 index 0000000000..6682adbe1e --- /dev/null +++ b/research/staged-donor-release/evidence/diagnostics/first-builder-endpoint-failure.txt @@ -0,0 +1,7 @@ +Traceback (most recent call last): + File "/private/tmp/four-kappa-native-base/source/native/new/code/borrow/bw_transport.py", line 416, in + run(a.word, a.out) + File "/private/tmp/four-kappa-native-base/source/native/new/code/borrow/bw_transport.py", line 284, in run + assert not bad, ('arbitrary-input endpoint (free warp algebra)', back, bad[:8]) + ^^^^^^^ +AssertionError: ('arbitrary-input endpoint (free warp algebra)', False, [('L', 113), ('L', 115), ('L', 116), ('L', 117), ('L', 118), ('L', 126), ('L', 132), ('L', 133)]) diff --git a/research/staged-donor-release/evidence/diagnostics/first-builder-native-failure.txt b/research/staged-donor-release/evidence/diagnostics/first-builder-native-failure.txt new file mode 100644 index 0000000000..da26d334d5 --- /dev/null +++ b/research/staged-donor-release/evidence/diagnostics/first-builder-native-failure.txt @@ -0,0 +1,10 @@ +Traceback (most recent call last): + File "/tmp/three-kappa-materialized/changed/source/new/fastnative/run_native.py", line 96, in + main() + File "/tmp/three-kappa-materialized/changed/source/new/fastnative/run_native.py", line 82, in main + run(label+'-'+script, command + list(map(str, arguments)), native) + File "/tmp/three-kappa-materialized/changed/source/new/fastnative/run_native.py", line 59, in run + need(result.returncode == 0, 'stage failed: '+name+'; see '+str(work/(name+'.log'))) + File "/private/tmp/three-kappa-materialized/changed/source/new/fastnative/common.py", line 12, in need + raise ValueError(message) +ValueError: stage failed: native-bw_transport.py; see /private/tmp/four-kappa-native-base/native-bw_transport.py.log diff --git a/research/staged-donor-release/evidence/full-wrapper/ENVIRONMENT.json b/research/staged-donor-release/evidence/full-wrapper/ENVIRONMENT.json new file mode 100644 index 0000000000..8772416f0b --- /dev/null +++ b/research/staged-donor-release/evidence/full-wrapper/ENVIRONMENT.json @@ -0,0 +1,16 @@ +{ + "python": "3.12.8 (main, Dec 7 2024, 10:11:37) [Clang 15.0.0 (clang-1500.3.9.4)]", + "platform": "macOS-26.5.1-arm64-arm-64bit", + "dependencies": { + "numpy": "1.26.4", + "scipy": "1.15.3", + "sympy": "1.14.0", + "mpmath": "1.3.0" + }, + "assertions_enabled": true, + "jobs": 1, + "wrapper_source_commit": "74afc9ff5cb437d3112c6279216d10250775cd98", + "invocation": "python3.12 -B research/staged-donor-release/full_replay.py --work /tmp/staged-release-pr-ready-20261018", + "reuse_current_native_option": false, + "retained_parent_reuse": true +} diff --git a/research/staged-donor-release/evidence/full-wrapper/PINS.json b/research/staged-donor-release/evidence/full-wrapper/PINS.json new file mode 100644 index 0000000000..18c4ce94e3 --- /dev/null +++ b/research/staged-donor-release/evidence/full-wrapper/PINS.json @@ -0,0 +1,93 @@ +{ + "files": { + "ENVIRONMENT.json": "8a142044f8e4e35fe2bc17241527f813fc46657628799eb3eef2303e9edbb8ac", + "NATIVE-RECEIPT.json": "b4a5db6ce35f5010a120e96f145cd4c9c376879ae7641d9cd77aa538d33d5dca", + "RESULT.json": "ee6c81cb34a38a85c596ec2e20c166c019add913c37c22ce2974fcc4db3617bd", + "STAGES.json": "1095f34281ae43f9a18663acf1f5490a793d497783fe1b9e141fbe6816ddcbd8", + "admission/RESULT.json": "3a73f0defa36e24ec768787ec67055ecf42d7e6bebda16e002fd0c8520bbf584", + "admission/STAGES.json": "64c9c607cfd16a7c4e3f9cf5a5f456e2b837de83a0ccf6c933df1e298c4ad209", + "admission/discovery.log": "ece8ce71444db4fea7a2088410cc26d28a1f0bac00d1ddc5865a6ff222143356", + "admission/discovery/RESULT.json": "20ef5c9527704081491f3e7a6d1aa1a5fd0ef8b645ccba76538d814eb48fc9ac", + "admission/discovery/STAGES.json": "8bafb50ee977674c1ae15351a08b701ae0afd14394948f0c09df2b3c7444273f", + "admission/discovery/assembly.log": "5ac7270c36308b094cb4444a6d400b01df7896062dd0de6d4f89823db72724f9", + "admission/discovery/audit.log": "95016e3446d444e4d370d7109dfdae02942362b0bcc466a7c51a41e757fd2f28", + "admission/discovery/bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "admission/discovery/emit.log": "e260c07293f4db63b729d93646a3bbe0271055be8ecfe481f400ea7005eb1f8b", + "admission/discovery/freeze.log": "a009d99400a44d0c6f83cc061ea24e6afefa45cc6a6c46885ea5a25fb0c26496", + "admission/discovery/independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "admission/discovery/invoice.log": "c902b592f7bcf9372d7097fa175c3131a6ddf75649a2538ca3f72f62ab52c24c", + "admission/outer-check_ledger.py.log": "df4467c4d6987e7fec54d2dd34de0c01c59c7559ddef5d036254fde5b33ec26c", + "admission/outer-independent_check.py.log": "f631025fdab4ef3f2848f1cc5c0ce385f443e86623d605c36c9c82a76131163b", + "admission/owners.log": "2eafaebba736752df3817a3863237919141a3445ea221b8a3e8269327a749c6a", + "admission/package/MANIFEST.json": "3b448af3760fc22d56dfa04473319896cc1946a949f694ee151f8dfc08c0e45e", + "admission/package/outer/LEDGER.json": "2a86f3e5923c400578cb13666bc2628eb90a83b0b0d07fddfbb595c3528bf205", + "admission/package/outer/OUTER-CLAIM.json": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553", + "admission/parent-lift.log": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "admission/rebind.log": "fe69dd9c58e26c0469bc94d92933e7e838df96dbb19873884e6740a8ccc97644", + "admission/release.log": "94f753277f2b6c44c2663a5bffee0b21fe0166c78e9dd3ee7b16de4582ae4a3a", + "admission/release/RELEASE-RECEIPT.json": "8ad79e5215ef98534d703dc40f9038f76dd5eff0392a681de1eee5e8ea3a9fb7", + "admission/release/outer.log": "781a17523d5b96fee631d993515f6b0c913248dbd49835b274fb35d5501ff800", + "admission/release/verify.log": "5083acb2656930c43eae2aa284cb4d7c5acb330c9eb47c4084836fb405773942", + "admission/release/verify/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "admission/release/verify/RESULT.json": "843d855216b56107bca0fc320b17d57799c6d342fa718c912145019c2db0b3e3", + "admission/release/verify/STAGES.json": "f04b0638b030ba8e17c9eaabd5c8ec7d93fbfc3bfd04786e46833c837e91e582", + "admission/release/verify/audit-local-566-base.log": "1bef1a62aff3f16262ebe476ae0b45dc26498ff27e2c702a40edf79541fb4654", + "admission/release/verify/audit-local-566-extra.log": "5c00902fc8c0bfd8c4d920b6f8653f9a8a4299a5f8cf09e1f10c012d7b92c5b1", + "admission/release/verify/declared-edit-review.log": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "admission/release/verify/delayed-release-independent-review.log": "6ac9eb1198cff958fed659958d2efbb70e13813da6baa962463bd8ebaf2074d4", + "admission/release/verify/fine-engine-oracle.log": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "admission/release/verify/geometry-controls.log": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "admission/release/verify/lemmag-labels.log": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "admission/release/verify/lift-parent.log": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "admission/release/verify/paired-extension-review.log": "0d8c8cf38f5ed3837bca466a50bb99c29e00877e5c215db52d523b3dc2ea1e78", + "admission/release/verify/preload-move-independent-review.log": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "admission/release/verify/rebind-566.log": "fe69dd9c58e26c0469bc94d92933e7e838df96dbb19873884e6740a8ccc97644", + "admission/release/verify/rebuild-borrow-words.log": "2b1b6c1883a4e7f673c0d143de50ad8aaf8111a9a9bb49498fcbee87798590ed", + "admission/release/verify/rebuild-words-566.log": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "admission/release/verify/reconstruct-owners.log": "2eafaebba736752df3817a3863237919141a3445ea221b8a3e8269327a749c6a", + "admission/release/verify/shared-kernel-independent-review.log": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "admission/release/verify/staged3605-review.log": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "admission/release/verify/strict-t74.log": "e9e1dcce207272b5a43d7220835f265693f8611adefea1d988d7201902160f7c", + "admission/release/verify/strict/ADMISSION-CONTROLS.json": "ce5d3c33b19ee61ec0ac879e887a8d7da57f8ad28753769624f5c173bde7c489", + "admission/release/verify/strict/ASSEMBLY.json": "49d08a188869b1835ceb4ca68bd58541c338af8510238c6b50e47bc6aa253bbc", + "admission/release/verify/strict/BIT-CONTROLS.json": "862375afcc3fba0706321d91f131c730e740b9f44a165436b1cf8c901e536d56", + "admission/release/verify/strict/INDEPENDENT.json": "980b942f071b4f86bbd93d8c60c095c724d74ba9fbd1cd4ebb3f1e6c77be5c33", + "admission/release/verify/strict/RESULT.json": "bb13f7450beafd89fe79a3c159508155c879193aa9f4ffed09f22da704a376e1", + "admission/release/verify/strict/STAGES.json": "327a90f101d592e26583c3dc4385c092a55b96e8afa1ea9f56e41770893b6c58", + "admission/release/verify/strict/admission.log": "1cee8d732e126c670f531018d65955c23828a7cc0af8d6ac4bb0f6672962a540", + "admission/release/verify/strict/assembly.log": "5ac7270c36308b094cb4444a6d400b01df7896062dd0de6d4f89823db72724f9", + "admission/release/verify/strict/audit.log": "95016e3446d444e4d370d7109dfdae02942362b0bcc466a7c51a41e757fd2f28", + "admission/release/verify/strict/bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "admission/release/verify/strict/bit.log": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "admission/release/verify/strict/emit.log": "e260c07293f4db63b729d93646a3bbe0271055be8ecfe481f400ea7005eb1f8b", + "admission/release/verify/strict/global/audit/PREFIX-AND-INVOICE.json": "c21c2c6eb85bc8cf0f24f206aa0fbf660b177dda7218afd3d4eff4bf2bdeaa05", + "admission/release/verify/strict/independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "admission/release/verify/strict/invoice.log": "c902b592f7bcf9372d7097fa175c3131a6ddf75649a2538ca3f72f62ab52c24c", + "admission/release/verify/two-sided-helper408-review.log": "4abfb0c9c0cf686fd4b74fd54f789ed681147444dc08a8698248782b7b5a8222", + "complete-admission.log": "81ad8b61d626314627922171fc55e43562c171a2650adfb15c463b858c7f49c9", + "fresh-native-base.log": "8aa18b1f489b661af8e82cfa0c3cc866876bc96440ec3c38efea6d91d3527175", + "fresh-native-extra.log": "a31d87e4e906ddd5812da5a16c60d293fa2fe34aa8af97e17240b46b3c398a96", + "native-base/COMMANDS.json": "c7a248216f4887031fb7da2255ccd8353c041dc0f7f521dfb3a0c4c7af6b239b", + "native-base/RESULT.json": "f70badae37358c4fe4e39bac744b3940ceacd654670ab3dffc0d0274ea987e90", + "native-base/ledgers-bw_emit.py.log": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "native-base/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native-base/native-bw_transport.py.log": "f01500fb5856ed05cf8dbab1e12914b66577105a477552025c6a1e4d6bc07515", + "native-base/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "native-base/phases-bw_phases.py.log": "e1e51f5f1ecb0bc51d0eed940065bb96e4d0a0ab3504442556684e57fe41c19c", + "native-base/wrappers-bw_adapters.py.log": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d", + "native-extra/COMMANDS.json": "f09ce42c5e4e67ce882e6f8542522ca2618c641d82783d525f27d495fb7f7f1d", + "native-extra/RESULT.json": "f9630d2cc7a13b9375e85fbe2ed8eb1bc01f49471fc5689ed7a4d507f5bcbbba", + "native-extra/ledgers-bw_emit.py.log": "3c22a15ea4f7a760b7e51d018db25509ecfea353334b14640a348f90cc9dfe8f", + "native-extra/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native-extra/native-bw_transport.py.log": "11ea25f4210da2a374d13061d1f55762515d30c6b5250f9b656625dbb2b13550", + "native-extra/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "native-extra/phases-bw_phases.py.log": "d7a5713f7edc4879dc2a38b0d97f0b2a025a4b498a6a715f22051b611a9435e0", + "native-extra/wrappers-bw_adapters.py.log": "92065498c6214eb987a9906ad8e018c6459465c91f142268c1fd7cd5d4a13e7d" + }, + "full_replay_sha256": "e3ea7fb08f70d55a71b88379fe23ff123ddb001459626c29839ddc8b60d2f7a6", + "receipts_archive_sha256": "59249307d403fd84fcfae72583a359dab6a37b9d7ec5c85e2aef7f3bde007657", + "scope": "Fresh default wrapper, both changed native providers and all seven admission stages. Retained unchanged parent/native ancestry remains authenticated reuse. Original scientific evidence and independent-review records are unchanged; this run is later execution evidence, not a new independent review.", + "source_archive_sha256": "fa4222b179c2b16c197620c4000781faa5f2364384e60ef623a95e88487677c8", + "source_commit": "74afc9ff5cb437d3112c6279216d10250775cd98", + "status": "PASS_FRESH_DEFAULT_WRAPPER_AND_TERMINAL_CROSS_BINDING" +} diff --git a/research/staged-donor-release/evidence/full-wrapper/README.md b/research/staged-donor-release/evidence/full-wrapper/README.md new file mode 100644 index 0000000000..f5dd12183a --- /dev/null +++ b/research/staged-donor-release/evidence/full-wrapper/README.md @@ -0,0 +1,37 @@ +# Default full-wrapper execution + +The default `full_replay.py` command passed end to end during PR preparation on +2026-10-18. Both changed native providers and all seven admission stages ran +fresh, including preparation and the entire original release. The scientific +wrapper and inputs are unchanged from commit +`74afc9ff5cb437d3112c6279216d10250775cd98`; `PINS.json` binds their exact hashes. +The older execution, repair and preparatory reuse remain preserved under +`../complete/` and are not replaced by this run. + +`RESULT.json`, `STAGES.json` and `ENVIRONMENT.json` are readable terminal records. +`RECEIPTS.tar.gz` retains the nested native, discovery, verification, strict +admission, invoice and outer records plus stage logs. Every member is listed +with its SHA256 in `PINS.json`. These records can be inspected without Git or +rerunning the heavy pipeline. The package's bounded verifier authenticates the +archive, exact endpoint, source bindings and complete stage coverage; it also +rejects inconsistent freshness, missing-stage, native-source and endpoint +receipts. This checks stored evidence, not a fresh heavy replay. + +Reproduce the full run with the Python and dependency versions in +`ENVIRONMENT.json`, from the repository root and with a fresh output directory: + +```sh +python3.12 -B research/staged-donor-release/full_replay.py --work /tmp/fresh-staged-release +``` + +Authenticate the retained run with the standard-library checker: + +```sh +python3.12 -B research/staged-donor-release/wrapper_evidence.py +``` + +The wrapper still reuses authenticated unchanged parent/native ancestry. +A no-reuse retained-parent cold run and hosted CI have not been run. This is +later execution evidence, not a new independent review or a discharge of the +inherited all-size and theorem-level assumptions. The prior independent reviews +remain scoped to their exact recorded commits. diff --git a/research/staged-donor-release/evidence/full-wrapper/RECEIPTS.tar.gz b/research/staged-donor-release/evidence/full-wrapper/RECEIPTS.tar.gz new file mode 100644 index 0000000000..c8ec418885 Binary files /dev/null and b/research/staged-donor-release/evidence/full-wrapper/RECEIPTS.tar.gz differ diff --git a/research/staged-donor-release/evidence/full-wrapper/RESULT.json b/research/staged-donor-release/evidence/full-wrapper/RESULT.json new file mode 100644 index 0000000000..88b85c6ea3 --- /dev/null +++ b/research/staged-donor-release/evidence/full-wrapper/RESULT.json @@ -0,0 +1,10 @@ +{ + "kappa": "17304188997660711638039999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017304188997660711638039999999999999999999998999999999999999999999999", + "release_receipt_sha256": "8ad79e5215ef98534d703dc40f9038f76dd5eff0392a681de1eee5e8ea3a9fb7", + "retained_parent_reused": true, + "reuse_current_native": false, + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_archive_sha256": "fa4222b179c2b16c197620c4000781faa5f2364384e60ef623a95e88487677c8", + "status": "PASS_DELAYED_RELEASE_COMPLETE_CONDITIONAL_RELEASE" +} diff --git a/research/staged-donor-release/evidence/full-wrapper/STAGES.json b/research/staged-donor-release/evidence/full-wrapper/STAGES.json new file mode 100644 index 0000000000..e00f7a41ac --- /dev/null +++ b/research/staged-donor-release/evidence/full-wrapper/STAGES.json @@ -0,0 +1,64 @@ +[ + { + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-B", + "/private/tmp/staged-release-pr-ready-20261018/inputs/source/new/fastnative/run_native.py", + "/private/tmp/staged-release-pr-ready-20261018/inputs/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "/private/tmp/staged-release-pr-ready-20261018/native-base" + ], + "exit_code": 0, + "log_sha256": "8aa18b1f489b661af8e82cfa0c3cc866876bc96440ec3c38efea6d91d3527175", + "name": "fresh-native-base" + }, + { + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-B", + "/private/tmp/staged-release-pr-ready-20261018/inputs/source/new/fastnative/run_native.py", + "/private/tmp/staged-release-pr-ready-20261018/inputs/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "/private/tmp/staged-release-pr-ready-20261018/native-extra" + ], + "exit_code": 0, + "log_sha256": "a31d87e4e906ddd5812da5a16c60d293fa2fe34aa8af97e17240b46b3c398a96", + "name": "fresh-native-extra" + }, + { + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-B", + "/private/tmp/staged-release-pr-ready-20261018/inputs/admit.py", + "--source", + "/private/tmp/staged-release-pr-ready-20261018/inputs/source", + "--fill", + "/private/tmp/staged-release-pr-ready-20261018/inputs/FILL.json.gz", + "--order", + "/private/tmp/staged-release-pr-ready-20261018/inputs/ORDER.json", + "--dispatch", + "/private/tmp/staged-release-pr-ready-20261018/inputs/DISPATCH.json", + "--native-cache", + "/private/tmp/staged-release-pr-ready-20261018/native-cache", + "--native-receipt", + "/private/tmp/staged-release-pr-ready-20261018/NATIVE-RECEIPT.json", + "--work", + "/private/tmp/staged-release-pr-ready-20261018/admission", + "--replica-helper-dir", + "/private/tmp/staged-release-pr-ready-20261018/inputs/helpers", + "--reconstructor", + "/private/tmp/staged-release-pr-ready-20261018/inputs/helpers/reconstruct_replica.py", + "--comparison-claim", + "/private/tmp/staged-release-pr-ready-20261018/inputs/PR2969-CLAIM.json", + "--blocknorm-checker", + "/private/tmp/staged-release-pr-ready-20261018/inputs/extension_blocknorm.py", + "--source-profile", + "staged3605", + "--comparison-profile", + "pr2969", + "--jobs", + "1" + ], + "exit_code": 0, + "log_sha256": "81ad8b61d626314627922171fc55e43562c171a2650adfb15c463b858c7f49c9", + "name": "complete-admission" + } +] diff --git a/research/staged-donor-release/evidence/native-base/COMMANDS.json b/research/staged-donor-release/evidence/native-base/COMMANDS.json new file mode 100644 index 0000000000..284ce14907 --- /dev/null +++ b/research/staged-donor-release/evidence/native-base/COMMANDS.json @@ -0,0 +1,85 @@ +[ + { + "step": "native-bw_transport.py", + "exit_code": 0, + "seconds": 0.6401202499982901, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-base-v2/source/native/new/code/borrow/bw_transport.py", + "/private/tmp/four-kappa-native-base-v2/INPUT.json.gz", + "/private/tmp/four-kappa-native-base-v2/native/local" + ] + }, + { + "step": "ledgers-bw_emit.py", + "exit_code": 0, + "seconds": 0.804032375002862, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-base-v2/source/native/new/code/borrow/bw_emit.py", + "/private/tmp/four-kappa-native-base-v2/native/local" + ] + }, + { + "step": "local-replay-bw_audit_local.py", + "exit_code": 0, + "seconds": 16.02003841700207, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-base-v2/source/native/new/code/borrow/bw_audit_local.py", + "/private/tmp/four-kappa-native-base-v2/native/local" + ] + }, + { + "step": "wrappers-bw_adapters.py", + "exit_code": 0, + "seconds": 1.0218950410053367, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/three-kappa-materialized/changed/source/new/fastnative/stage.py", + "--vendor", + "/private/tmp/four-kappa-native-base-v2/source", + "--script", + "bw_adapters.py", + "/private/tmp/four-kappa-native-base-v2/native/local/CANONICAL-WORD.json.gz", + "/private/tmp/four-kappa-native-base-v2/native/local/RESIDUAL-ADAPTERS.json", + "/private/tmp/four-kappa-native-base-v2/native/local/WRAPPER-CHECKS.json" + ] + }, + { + "step": "phases-bw_phases.py", + "exit_code": 0, + "seconds": 11.42662416701205, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/three-kappa-materialized/changed/source/new/fastnative/stage.py", + "--vendor", + "/private/tmp/four-kappa-native-base-v2/source", + "--script", + "bw_phases.py", + "/private/tmp/four-kappa-native-base-v2/native/local" + ] + }, + { + "step": "phases-bw_check_recipes.py", + "exit_code": 0, + "seconds": 6.193945874998462, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-base-v2/source/native/new/code/borrow/bw_check_recipes.py", + "/private/tmp/four-kappa-native-base-v2/native/local" + ] + } +] diff --git a/research/staged-donor-release/evidence/native-base/LOCAL-CHECKS.json b/research/staged-donor-release/evidence/native-base/LOCAL-CHECKS.json new file mode 100644 index 0000000000..39d91d34bc --- /dev/null +++ b/research/staged-donor-release/evidence/native-base/LOCAL-CHECKS.json @@ -0,0 +1,40 @@ +{ + "forward": { + "sha256": "4a6fb4244033da492c50fe7b708f0cad38b191d330b586ed5e7764f48cddfe92", + "events": 22766, + "scalar_macros": 17449, + "warp_events": 240, + "real_component_primitive_bound": 158144, + "paid_profile": { + "1": 2437, + "2": 724, + "3": 226, + "4": 102, + "5": 20, + "8": 8 + }, + "all_columns": 632, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true, + "zero_buffers_returned_to_zero": 91 + }, + "backward": { + "sha256": "a913df9b8d5d10884c8d4f07b6ee598c9cb4ec4b331a8079fb1e6d597aaea7a4", + "events": 22766, + "scalar_macros": 17449, + "warp_events": 240, + "real_component_primitive_bound": 158192, + "paid_profile": { + "1": 2437, + "2": 724, + "3": 226, + "4": 102, + "5": 20, + "8": 8 + }, + "all_columns": 632, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true, + "zero_buffers_returned_to_zero": 91 + } +} diff --git a/research/staged-donor-release/evidence/native-base/RESULT.json b/research/staged-donor-release/evidence/native-base/RESULT.json new file mode 100644 index 0000000000..4acd02437c --- /dev/null +++ b/research/staged-donor-release/evidence/native-base/RESULT.json @@ -0,0 +1,55 @@ +{ + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "engine": "sparse", + "word_sha256": "0aca7560603d65902a50d68af43f594abd93b09594bac24878b846b1e51475fa", + "source_sha256": { + "accelerators/SPARSE-NOTICE.md": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "accelerators/SPARSE-PROOF.md": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "accelerators/sparse_state.py": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "accelerators/tables.py": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "native/new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "native/new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "native/new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "native/new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "native/new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "native/new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "native/new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "native/new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "native/new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "native/new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "native/new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "native/new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "native/new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + "steps": [ + { + "step": "native", + "exit_code": 0, + "seconds": 0.6404481659992598 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 0.8266185420070542 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 16.0204907090083 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 1.0223347499995725 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 17.62141270900611 + } + ], + "seconds": 36.147309457999654, + "python": "3.12.8", + "scope": "Full five-stage native replay including independent all-column warp recipes and original rejection controls; supplier/outer admission separate." +} diff --git a/research/staged-donor-release/evidence/native-base/WRAPPER-CHECKS.json b/research/staged-donor-release/evidence/native-base/WRAPPER-CHECKS.json new file mode 100644 index 0000000000..15fe2d89b1 --- /dev/null +++ b/research/staged-donor-release/evidence/native-base/WRAPPER-CHECKS.json @@ -0,0 +1,962 @@ +{ + "status": "PASS_RESIDUAL_WRAPPERS_ARE_EXACT", + "frames": 25, + "hyperplane_end_pairs": [ + { + "frame": 0, + "terminal": 251, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 252, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 253, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 254, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 255, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 256, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 257, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 258, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 259, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 260, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 261, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 262, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 263, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 264, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 265, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 266, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 267, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 268, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 269, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 270, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 275, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 276, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 277, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 278, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 114, + "terminal": 255, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 114, + "terminal": 272, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 114, + "terminal": 274, + "entrance_rank": 1, + "terminal_rank": 8, + "residual_width": 7 + }, + { + "frame": 115, + "terminal": 262, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 271, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 273, + "entrance_rank": 1, + "terminal_rank": 8, + "residual_width": 7 + }, + { + "frame": 115, + "terminal": 279, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 280, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + } + ], + "cold_hyperplane_end_pairs": 24, + "wrappers_reject": [ + "wrong global phase", + "wrong translation", + "wrong quadratic form", + "sides swapped", + "wrong width", + "hpe: U-wrapper decoded against a FULL ending", + "hpe: width misreported as 9 - dim E", + "hpe: wrong terminal hyperplane", + "hpe: pre wrapper resolved to the FULL recipe R_{E,FULL}", + "hpe: wrong global phase", + "cold hpe: identity pre wrapper instead of R_{0,U}", + "cold hpe: identity post wrapper instead of L_{0,U}", + "cold hpe: no wrappers (cold FULL convention L = R = I)", + "cold hpe: U-wrapper decoded against a FULL ending", + "cold hpe: width misreported as 9", + "cold hpe: wrong terminal hyperplane", + "cold hpe: wrong global phase", + "warp: wrong global phase", + "warp: wrong translation", + "warp: wrong linear phase", + "warp: wrong quadratic form", + "warp: recipe of another operator", + "warp: inverse recipe used as the warp", + "warp: wrong G (frame-changed column)", + "warp: non-invertible G" + ], + "all_even_weight": false, + "warp_recipes_exact_on_all_512_columns": [ + { + "op": 1, + "from_frame": 281, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 2, + "from_frame": 281, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 3, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 4, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 5, + "from_frame": 260, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 6, + "from_frame": 257, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 7, + "from_frame": 286, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 8, + "from_frame": 253, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 9, + "from_frame": 253, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 10, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 11, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 12, + "from_frame": 257, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 13, + "from_frame": 260, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 14, + "from_frame": 263, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 15, + "from_frame": 263, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 16, + "from_frame": 264, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 17, + "from_frame": 264, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 18, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 19, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 20, + "from_frame": 267, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 21, + "from_frame": 267, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 22, + "from_frame": 291, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 23, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 24, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 25, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 26, + "from_frame": 281, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 27, + "from_frame": 281, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 28, + "from_frame": 284, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 29, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 30, + "from_frame": 293, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 31, + "from_frame": 295, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 32, + "from_frame": 296, + "to_frame": 297, + "columns_checked": 512 + }, + { + "op": 33, + "from_frame": 296, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 34, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 35, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 36, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 37, + "from_frame": 299, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 38, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 39, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 40, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 41, + "from_frame": 301, + "to_frame": 302, + "columns_checked": 512 + }, + { + "op": 42, + "from_frame": 303, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 43, + "from_frame": 263, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 44, + "from_frame": 267, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 45, + "from_frame": 263, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 46, + "from_frame": 253, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 47, + "from_frame": 260, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 48, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 49, + "from_frame": 264, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 50, + "from_frame": 257, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 51, + "from_frame": 260, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 52, + "from_frame": 264, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 53, + "from_frame": 257, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 54, + "from_frame": 254, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 55, + "from_frame": 267, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 56, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 57, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 58, + "from_frame": 253, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 59, + "from_frame": 253, + "to_frame": 305, + "columns_checked": 512 + }, + { + "op": 60, + "from_frame": 253, + "to_frame": 306, + "columns_checked": 512 + }, + { + "op": 61, + "from_frame": 254, + "to_frame": 307, + "columns_checked": 512 + }, + { + "op": 62, + "from_frame": 254, + "to_frame": 308, + "columns_checked": 512 + }, + { + "op": 63, + "from_frame": 257, + "to_frame": 309, + "columns_checked": 512 + }, + { + "op": 64, + "from_frame": 260, + "to_frame": 310, + "columns_checked": 512 + }, + { + "op": 65, + "from_frame": 311, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 66, + "from_frame": 312, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 67, + "from_frame": 313, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 68, + "from_frame": 315, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 69, + "from_frame": 316, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 70, + "from_frame": 317, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 71, + "from_frame": 296, + "to_frame": 138, + "columns_checked": 512 + }, + { + "op": 72, + "from_frame": 296, + "to_frame": 138, + "columns_checked": 512 + } + ], + "all_totally_isotropic": false, + "detail": [ + { + "frame": 114, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 51 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 115, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 30 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 116, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 117, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 118, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 82, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 119, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 120, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 121, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 85, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 122, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 76, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 123, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 82, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 124, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 125, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 126, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 76, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 127, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 120, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 128, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 97, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 129, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 102, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 130, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 97, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 131, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 102 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 132, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 85 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 133, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 459 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 134, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 75 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 135, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 120 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 136, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 45 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 137, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 429, + 30 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 138, + "entrance_rank": 4, + "residual_width": 5, + "vectors": [ + 264, + 136, + 85, + 51 + ], + "all_even_weight": true, + "totally_isotropic": false + } + ] +} diff --git a/research/staged-donor-release/evidence/native-extra/COMMANDS.json b/research/staged-donor-release/evidence/native-extra/COMMANDS.json new file mode 100644 index 0000000000..c4d88a4eee --- /dev/null +++ b/research/staged-donor-release/evidence/native-extra/COMMANDS.json @@ -0,0 +1,85 @@ +[ + { + "step": "native-bw_transport.py", + "exit_code": 0, + "seconds": 0.630308291001711, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-extra/source/native/new/code/borrow/bw_transport.py", + "/private/tmp/four-kappa-native-extra/INPUT.json.gz", + "/private/tmp/four-kappa-native-extra/native/local" + ] + }, + { + "step": "ledgers-bw_emit.py", + "exit_code": 0, + "seconds": 0.6930233339953702, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-extra/source/native/new/code/borrow/bw_emit.py", + "/private/tmp/four-kappa-native-extra/native/local" + ] + }, + { + "step": "local-replay-bw_audit_local.py", + "exit_code": 0, + "seconds": 15.505213542011916, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-extra/source/native/new/code/borrow/bw_audit_local.py", + "/private/tmp/four-kappa-native-extra/native/local" + ] + }, + { + "step": "wrappers-bw_adapters.py", + "exit_code": 0, + "seconds": 0.9997772079950664, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/three-kappa-materialized/changed/source/new/fastnative/stage.py", + "--vendor", + "/private/tmp/four-kappa-native-extra/source", + "--script", + "bw_adapters.py", + "/private/tmp/four-kappa-native-extra/native/local/CANONICAL-WORD.json.gz", + "/private/tmp/four-kappa-native-extra/native/local/RESIDUAL-ADAPTERS.json", + "/private/tmp/four-kappa-native-extra/native/local/WRAPPER-CHECKS.json" + ] + }, + { + "step": "phases-bw_phases.py", + "exit_code": 0, + "seconds": 11.607374292012537, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/three-kappa-materialized/changed/source/new/fastnative/stage.py", + "--vendor", + "/private/tmp/four-kappa-native-extra/source", + "--script", + "bw_phases.py", + "/private/tmp/four-kappa-native-extra/native/local" + ] + }, + { + "step": "phases-bw_check_recipes.py", + "exit_code": 0, + "seconds": 7.324629791008192, + "command": [ + "/private/tmp/three-kappa-env/bin/python", + "-I", + "-B", + "/private/tmp/four-kappa-native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "/private/tmp/four-kappa-native-extra/native/local" + ] + } +] diff --git a/research/staged-donor-release/evidence/native-extra/LOCAL-CHECKS.json b/research/staged-donor-release/evidence/native-extra/LOCAL-CHECKS.json new file mode 100644 index 0000000000..39d91d34bc --- /dev/null +++ b/research/staged-donor-release/evidence/native-extra/LOCAL-CHECKS.json @@ -0,0 +1,40 @@ +{ + "forward": { + "sha256": "4a6fb4244033da492c50fe7b708f0cad38b191d330b586ed5e7764f48cddfe92", + "events": 22766, + "scalar_macros": 17449, + "warp_events": 240, + "real_component_primitive_bound": 158144, + "paid_profile": { + "1": 2437, + "2": 724, + "3": 226, + "4": 102, + "5": 20, + "8": 8 + }, + "all_columns": 632, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true, + "zero_buffers_returned_to_zero": 91 + }, + "backward": { + "sha256": "a913df9b8d5d10884c8d4f07b6ee598c9cb4ec4b331a8079fb1e6d597aaea7a4", + "events": 22766, + "scalar_macros": 17449, + "warp_events": 240, + "real_component_primitive_bound": 158192, + "paid_profile": { + "1": 2437, + "2": 724, + "3": 226, + "4": 102, + "5": 20, + "8": 8 + }, + "all_columns": 632, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true, + "zero_buffers_returned_to_zero": 91 + } +} diff --git a/research/staged-donor-release/evidence/native-extra/RESULT.json b/research/staged-donor-release/evidence/native-extra/RESULT.json new file mode 100644 index 0000000000..7dd2d8a846 --- /dev/null +++ b/research/staged-donor-release/evidence/native-extra/RESULT.json @@ -0,0 +1,55 @@ +{ + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "engine": "sparse", + "word_sha256": "6928ad79dc683e7e7bbf4b5da60f2df91f478c58b797922d6df41d9d43c87048", + "source_sha256": { + "accelerators/SPARSE-NOTICE.md": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "accelerators/SPARSE-PROOF.md": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "accelerators/sparse_state.py": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "accelerators/tables.py": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "native/new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "native/new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "native/new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "native/new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "native/new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "native/new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "native/new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "native/new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "native/new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "native/new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "native/new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "native/new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "native/new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + "steps": [ + { + "step": "native", + "exit_code": 0, + "seconds": 0.6307048750022659 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 0.6934268749901094 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 15.505636583009618 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 1.0001233749935636 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 18.93311595900741 + } + ], + "seconds": 36.77738720799971, + "python": "3.12.8", + "scope": "Full five-stage native replay including independent all-column warp recipes and original rejection controls; supplier/outer admission separate." +} diff --git a/research/staged-donor-release/evidence/native-extra/WRAPPER-CHECKS.json b/research/staged-donor-release/evidence/native-extra/WRAPPER-CHECKS.json new file mode 100644 index 0000000000..15fe2d89b1 --- /dev/null +++ b/research/staged-donor-release/evidence/native-extra/WRAPPER-CHECKS.json @@ -0,0 +1,962 @@ +{ + "status": "PASS_RESIDUAL_WRAPPERS_ARE_EXACT", + "frames": 25, + "hyperplane_end_pairs": [ + { + "frame": 0, + "terminal": 251, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 252, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 253, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 254, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 255, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 256, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 257, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 258, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 259, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 260, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 261, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 262, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 263, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 264, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 265, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 266, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 267, + "entrance_rank": 0, + "terminal_rank": 4, + "residual_width": 4 + }, + { + "frame": 0, + "terminal": 268, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 269, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 270, + "entrance_rank": 0, + "terminal_rank": 8, + "residual_width": 8 + }, + { + "frame": 0, + "terminal": 275, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 276, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 277, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 0, + "terminal": 278, + "entrance_rank": 0, + "terminal_rank": 7, + "residual_width": 7 + }, + { + "frame": 114, + "terminal": 255, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 114, + "terminal": 272, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 114, + "terminal": 274, + "entrance_rank": 1, + "terminal_rank": 8, + "residual_width": 7 + }, + { + "frame": 115, + "terminal": 262, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 271, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 273, + "entrance_rank": 1, + "terminal_rank": 8, + "residual_width": 7 + }, + { + "frame": 115, + "terminal": 279, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + }, + { + "frame": 115, + "terminal": 280, + "entrance_rank": 1, + "terminal_rank": 7, + "residual_width": 6 + } + ], + "cold_hyperplane_end_pairs": 24, + "wrappers_reject": [ + "wrong global phase", + "wrong translation", + "wrong quadratic form", + "sides swapped", + "wrong width", + "hpe: U-wrapper decoded against a FULL ending", + "hpe: width misreported as 9 - dim E", + "hpe: wrong terminal hyperplane", + "hpe: pre wrapper resolved to the FULL recipe R_{E,FULL}", + "hpe: wrong global phase", + "cold hpe: identity pre wrapper instead of R_{0,U}", + "cold hpe: identity post wrapper instead of L_{0,U}", + "cold hpe: no wrappers (cold FULL convention L = R = I)", + "cold hpe: U-wrapper decoded against a FULL ending", + "cold hpe: width misreported as 9", + "cold hpe: wrong terminal hyperplane", + "cold hpe: wrong global phase", + "warp: wrong global phase", + "warp: wrong translation", + "warp: wrong linear phase", + "warp: wrong quadratic form", + "warp: recipe of another operator", + "warp: inverse recipe used as the warp", + "warp: wrong G (frame-changed column)", + "warp: non-invertible G" + ], + "all_even_weight": false, + "warp_recipes_exact_on_all_512_columns": [ + { + "op": 1, + "from_frame": 281, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 2, + "from_frame": 281, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 3, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 4, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 5, + "from_frame": 260, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 6, + "from_frame": 257, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 7, + "from_frame": 286, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 8, + "from_frame": 253, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 9, + "from_frame": 253, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 10, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 11, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 12, + "from_frame": 257, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 13, + "from_frame": 260, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 14, + "from_frame": 263, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 15, + "from_frame": 263, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 16, + "from_frame": 264, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 17, + "from_frame": 264, + "to_frame": 282, + "columns_checked": 512 + }, + { + "op": 18, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 19, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 20, + "from_frame": 267, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 21, + "from_frame": 267, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 22, + "from_frame": 291, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 23, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 24, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 25, + "from_frame": 291, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 26, + "from_frame": 281, + "to_frame": 292, + "columns_checked": 512 + }, + { + "op": 27, + "from_frame": 281, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 28, + "from_frame": 284, + "to_frame": 285, + "columns_checked": 512 + }, + { + "op": 29, + "from_frame": 284, + "to_frame": 283, + "columns_checked": 512 + }, + { + "op": 30, + "from_frame": 293, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 31, + "from_frame": 295, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 32, + "from_frame": 296, + "to_frame": 297, + "columns_checked": 512 + }, + { + "op": 33, + "from_frame": 296, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 34, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 35, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 36, + "from_frame": 299, + "to_frame": 298, + "columns_checked": 512 + }, + { + "op": 37, + "from_frame": 299, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 38, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 39, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 40, + "from_frame": 301, + "to_frame": 300, + "columns_checked": 512 + }, + { + "op": 41, + "from_frame": 301, + "to_frame": 302, + "columns_checked": 512 + }, + { + "op": 42, + "from_frame": 303, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 43, + "from_frame": 263, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 44, + "from_frame": 267, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 45, + "from_frame": 263, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 46, + "from_frame": 253, + "to_frame": 304, + "columns_checked": 512 + }, + { + "op": 47, + "from_frame": 260, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 48, + "from_frame": 254, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 49, + "from_frame": 264, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 50, + "from_frame": 257, + "to_frame": 289, + "columns_checked": 512 + }, + { + "op": 51, + "from_frame": 260, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 52, + "from_frame": 264, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 53, + "from_frame": 257, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 54, + "from_frame": 254, + "to_frame": 288, + "columns_checked": 512 + }, + { + "op": 55, + "from_frame": 267, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 56, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 57, + "from_frame": 266, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 58, + "from_frame": 253, + "to_frame": 290, + "columns_checked": 512 + }, + { + "op": 59, + "from_frame": 253, + "to_frame": 305, + "columns_checked": 512 + }, + { + "op": 60, + "from_frame": 253, + "to_frame": 306, + "columns_checked": 512 + }, + { + "op": 61, + "from_frame": 254, + "to_frame": 307, + "columns_checked": 512 + }, + { + "op": 62, + "from_frame": 254, + "to_frame": 308, + "columns_checked": 512 + }, + { + "op": 63, + "from_frame": 257, + "to_frame": 309, + "columns_checked": 512 + }, + { + "op": 64, + "from_frame": 260, + "to_frame": 310, + "columns_checked": 512 + }, + { + "op": 65, + "from_frame": 311, + "to_frame": 287, + "columns_checked": 512 + }, + { + "op": 66, + "from_frame": 312, + "to_frame": 294, + "columns_checked": 512 + }, + { + "op": 67, + "from_frame": 313, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 68, + "from_frame": 315, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 69, + "from_frame": 316, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 70, + "from_frame": 317, + "to_frame": 314, + "columns_checked": 512 + }, + { + "op": 71, + "from_frame": 296, + "to_frame": 138, + "columns_checked": 512 + }, + { + "op": 72, + "from_frame": 296, + "to_frame": 138, + "columns_checked": 512 + } + ], + "all_totally_isotropic": false, + "detail": [ + { + "frame": 114, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 51 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 115, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 30 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 116, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 117, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 118, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 82, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 119, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 120, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 121, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 85, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 122, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 76, + 42 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 123, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 82, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 124, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 125, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 75, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 126, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 76, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 127, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 120, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 128, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 97, + 7 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 129, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 102, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 130, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 97, + 25 + ], + "all_even_weight": false, + "totally_isotropic": false + }, + { + "frame": 131, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 102 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 132, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 85 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 133, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 459 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 134, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 75 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 135, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 120 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 136, + "entrance_rank": 1, + "residual_width": 8, + "vectors": [ + 45 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 137, + "entrance_rank": 2, + "residual_width": 7, + "vectors": [ + 429, + 30 + ], + "all_even_weight": true, + "totally_isotropic": true + }, + { + "frame": 138, + "entrance_rank": 4, + "residual_width": 5, + "vectors": [ + 264, + 136, + 85, + 51 + ], + "all_even_weight": true, + "totally_isotropic": false + } + ] +} diff --git a/research/staged-donor-release/evidence_check.py b/research/staged-donor-release/evidence_check.py new file mode 100644 index 0000000000..a3bbd715b1 --- /dev/null +++ b/research/staged-donor-release/evidence_check.py @@ -0,0 +1,44 @@ +"""Semantic binding of stored complete finite release; not a fresh full replay.""" +from pathlib import Path +from fractions import Fraction as Q +import hashlib,json +P=Path(__file__).parent +PINS_SHA='5f2a64d8df97ab0f94f7c1524af917945b6292be277e8bd2393ea4b8cf78f1ef' +def need(ok,msg): + if not ok:raise ValueError(msg) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_text()) +def semantic(r,release,native,invoice,independent): + price=read(P/'LEAD1-PRICE.json');profile=price['profile'];K=Q(price['root_interval'][0])-Q(1,10**46)-Q(1,10**70) + need(r['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE' and release['status']=='PASS_RELEASE','terminal complete status') + need(Q(r['kappa'])==Q(r['kappa_decimal'])==Q(release['kappa_decimal'])==K>Q(read(P/'sources/T360-PRICE.json')['root_interval'][1]),'strict latest endpoint and both exact backoffs') + need(r['profile']==profile and (r['replicas'],r['actual_expected_helpers'])==(360,408),'exact full profile') + need(r['source_file_count']==652 and r['source_manifest_sha256']==native['manifest_sha256'],'actual v2 source') + need(native['fresh_current_provider_count']==2 and native['reused_retained_parent'] is True,'actual native execution and retained parent scope') + for tag in ('base','extra'):need(native['providers'][tag]['word_sha256']==sha(P/'lead1-words'/f'DELAYED-{tag}.json.gz'),'changed native words') + need([s['name'] for s in r['stages']]==['owners','parent-lift','rebind','discovery','outer-check_ledger.py','outer-independent_check.py','release'] and all(s['exit_code']==0 for s in r['stages']),'all seven original stages with explicit preparatory reuse') + need(invoice['status']=='PASS_INDEPENDENT_MIXED_ASYNC_SCALAR_PREFIX_AND_FINITE_INVOICE','finite invoice') + need((invoice['physical'],invoice['live'],invoice['helpers'],invoice['centres'],invoice['private_zero_buffers'])==(323069,322560,408,8,91),'all physical stock') + need(invoice['selected_local_paid_profile']=={k:n*3240 for k,n in {'1':2437,'2':724,'3':226,'4':102,'5':20,'8':8}.items()},'every actual local bill') + checks=invoice['strict_checks'];need(set(checks)=={'local_primitive_bound','logical','router','literal','mass','precision','tape','row','halving'} and all(v is True for v in checks.values()),'every strict finite cost check') + bn=invoice['blocknorm'];need(bn['replicas']==360 and bn['physical_families']==323069 and bn['retained_payload_bits']==2048 and bn['required_reserve_bits']<2048,'precision and block stock') + need(invoice['global_prefix_bits']==bn['actual_prefix_bits'] and invoice['charged_prefix_bits']==2048,'actual global precision') + for pid in ('gauge44','extra'): + for direction in ('forward','backward'): + e=bn['endpoint_replay'][pid][direction];need(e['all_arbitrary_columns']==632 and e['helper_to_data_response_zero'] and e['centres_first_clear_and_terminal_zero']==8 and e['zero_buffers_allocated_and_cleared']==91,'arbitrary-dirty endpoints') + need(independent['status']=='PASS_INDEPENDENT_VARIABLE_T_LITERAL_WINDOWS_CHARTS_PREFIX_ROW' and independent['roles']==1321920 and independent['checked_whole_helper_widths']==1321920 and independent['checked_busy_family_windows']==1321920,'all roles in fresh original independent admission') + need(all(row=={'1':2437,'2':724,'3':226,'4':102,'5':20,'8':8} for row in independent['local_profiles'].values()),'independent actual local invoices') + return K + +def check(): + d=P/'evidence/complete';need(PINS_SHA is not None and sha(d/'PINS.json')==PINS_SHA,'frozen receipt inventory');pins=read(d/'PINS.json') + for name,h in pins['files'].items():need(Path(name).name==name and sha(d/name)==h,'stored receipt '+name) + r=read(d/'RESULT.json');release=read(d/'RELEASE-RECEIPT.json');native=read(d/'NATIVE-RECEIPT.json');invoice=read(d/'PREFIX-AND-INVOICE.json');independent=read(d/'INDEPENDENT.json');semantic(r,release,native,invoice,independent) + need(r['release_receipt_sha256']==sha(d/'RELEASE-RECEIPT.json') and r['native_receipt_sha256']==sha(d/'NATIVE-RECEIPT.json') and r['package_manifest_sha256']==sha(d/'PACKAGE-MANIFEST.json')==release['manifest_sha256'],'full receipt hash chain') + coverage=read(d/'REUSE-COVERAGE.json');need(coverage['status']=='AUTHENTICATED_PREPARATORY_STAGE_REUSE_AFTER_DECLARED_EDIT_BINDING_REPAIR' and r['reuse_coverage_sha256']==sha(d/'REUSE-COVERAGE.json'),'explicit preparation reuse') + need(read(d/'SOURCE-DERIVATION.json')['new_manifest']==r['source_manifest_sha256'],'derived source binding') + stages=read(d/'VERIFY-STAGES.json');need(all(s['exit_code']==0 for s in stages) and 'delayed-release-independent-review' in {s['name'] for s in stages} and 'staged3605-review' in {s['name'] for s in stages},'predecessor and new reconstruction checks') + strict=read(d/'STRICT-STAGES.json');need([s['name'] for s in strict]==['bind','emit','audit','invoice','assembly','admission','bit','independent'] and all(s['exit_code']==0 for s in strict),'complete strict finite admission') + need(len(read(d/'ADMISSION-CONTROLS.json')['rejected_controls'])==139 and len(read(d/'GEOMETRY-CONTROLS.json')['rejected'])==6,'retained semantic controls') + return 'PASS_AUTHENTICATED_STORED_COMPLETE_RELEASE_NOT_FRESH_REPLAY' +if __name__=='__main__':print(check()) diff --git a/research/staged-donor-release/evidence_controls.py b/research/staged-donor-release/evidence_controls.py new file mode 100644 index 0000000000..7892ebb360 --- /dev/null +++ b/research/staged-donor-release/evidence_controls.py @@ -0,0 +1,16 @@ +"""Semantic receipt mutants; run after authentication, independently of byte pins.""" +import copy,json +from pathlib import Path +from evidence_check import semantic,read,P + +def main(): + d=P/'evidence/complete';original=[read(d/f) for f in ['RESULT.json','RELEASE-RECEIPT.json','NATIVE-RECEIPT.json','PREFIX-AND-INVOICE.json','INDEPENDENT.json']];semantic(*original) + cases=[('wrong_profile',lambda x:x[0]['profile'].__setitem__('3',x[0]['profile']['3']-1)),('missing_private_stock',lambda x:x[3].__setitem__('private_zero_buffers',90)),('unpaid_native_word',lambda x:x[2]['providers']['base'].__setitem__('word_sha256','0'*64)),('unchecked_tape',lambda x:x[3]['strict_checks'].__setitem__('tape',False)),('false_dirty_cleanup',lambda x:x[3]['blocknorm']['endpoint_replay']['extra']['backward'].__setitem__('zero_buffers_allocated_and_cleared',90)),('skipped_roles',lambda x:x[4].__setitem__('checked_busy_family_windows',1321919)),('unexecuted_release',lambda x:x[0]['stages'][-1].__setitem__('exit_code',1)),('no_retained_parent_disclosure',lambda x:x[2].__setitem__('reused_retained_parent',False)),('undercharged_precision',lambda x:x[3].__setitem__('charged_prefix_bits',1024))] + rejected=[] + for name,mutate in cases: + trial=copy.deepcopy(original);mutate(trial) + try:semantic(*trial) + except (ValueError,KeyError):rejected.append(name) + else:raise ValueError('semantic receipt mutant accepted '+name) + print(json.dumps(dict(status='PASS_SEMANTIC_COMPLETE_RECEIPT_CONTROLS',rejected=rejected),indent=2)) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/export_evidence.py b/research/staged-donor-release/export_evidence.py new file mode 100644 index 0000000000..543175a261 --- /dev/null +++ b/research/staged-donor-release/export_evidence.py @@ -0,0 +1,18 @@ +"""Freeze terminal receipts and logs, retaining failures/reuse separately.""" +from pathlib import Path +import argparse,hashlib,json,shutil +P=Path(__file__).parent +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--admission',type=Path,required=True);ap.add_argument('--inputs',type=Path,required=True);a=ap.parse_args();w=a.admission;rel=w/'release-v2';s=rel/'verify/strict';out=P/'evidence/complete';assert not out.exists();out.mkdir() + items={'RESULT.json':w/'RESULT-v2.json','RELEASE-RECEIPT.json':rel/'RELEASE-RECEIPT.json','NATIVE-RECEIPT.json':a.inputs/'NATIVE-RECEIPT.json','STAGES.json':w/'V2-STAGES.json','REUSE-COVERAGE.json':w/'V2-REUSE-COVERAGE.json','SOURCE-DERIVATION.json':a.inputs/'V2-DERIVATION.json','PACKAGE-MANIFEST.json':w/'package/MANIFEST.json','VERIFY-RESULT.json':rel/'verify/RESULT.json','VERIFY-STAGES.json':rel/'verify/STAGES.json','STRICT-RESULT.json':s/'RESULT.json','STRICT-STAGES.json':s/'STAGES.json','INDEPENDENT.json':s/'INDEPENDENT.json','PREFIX-AND-INVOICE.json':s/'global/audit/PREFIX-AND-INVOICE.json','ASSEMBLY.json':s/'ASSEMBLY.json','ADMISSION-CONTROLS.json':s/'ADMISSION-CONTROLS.json','BIT-CONTROLS.json':s/'BIT-CONTROLS.json','GEOMETRY-CONTROLS.json':rel/'verify/GEOMETRY-CONTROLS.json','OUTER-LEDGER.json':w/'package/outer/LEDGER.json','OUTER-CLAIM.json':w/'package/outer/OUTER-CLAIM.json','FIRST-FAILED-VERIFY-STAGES.json':w/'release/verify/STAGES.json','FIRST-FAILED-REBUILD.txt':w/'release/verify/rebuild-borrow-words.log','FIRST-FAILED-RELEASE.txt':w/'release.log','RELEASE-V2.txt':w/'release-v2.log','VERIFY.txt':rel/'verify.log','OUTER.txt':rel/'outer.log'} + for name,f in items.items():assert f.is_file(),f;shutil.copy2(f,out/name) + # Preserve and bind each directly recorded execution log, without large generated trees. + for prefix,root,stages in [('PREP',w,json.loads((w/'V2-STAGES.json').read_text())[:-1]),('VERIFY',rel/'verify',json.loads((rel/'verify/STAGES.json').read_text())),('STRICT',s,json.loads((s/'STAGES.json').read_text()))]: + for stage in stages: + f=root/(stage['name']+'.log') + if not f.exists():continue + if 'log_sha256' in stage:assert sha(f)==stage['log_sha256'] + name=prefix+'-'+stage['name']+'.txt';shutil.copy2(f,out/name) + pins={f.name:sha(f) for f in sorted(out.iterdir())};(out/'PINS.json').write_text(json.dumps(dict(scope='Authenticated stored completed execution, not a fresh replay',files=pins),sort_keys=True,indent=2)+'\n');print(sha(out/'PINS.json')) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/export_inputs.py b/research/staged-donor-release/export_inputs.py new file mode 100644 index 0000000000..3707daf6c8 --- /dev/null +++ b/research/staged-donor-release/export_inputs.py @@ -0,0 +1,22 @@ +"""Retain the exact full source/cache/owner closure and reconstruction predecessor.""" +from pathlib import Path +import argparse,tarfile,hashlib,json +P=Path(__file__).parent +sha=lambda f:hashlib.sha256(f.read_bytes()).hexdigest() +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--inputs',type=Path,required=True);ap.add_argument('--predecessor',type=Path,required=True);ap.add_argument('--retained',type=Path,required=True);ap.add_argument('--allocation',type=Path,required=True);ap.add_argument('--fill',type=Path,required=True);a=ap.parse_args();src=a.inputs;items={} + for folder in ['source','native-cache']: + for f in (src/folder).rglob('*'): + if f.is_file():items[f.relative_to(src).as_posix()]=f + for n in ['admit.py','NATIVE-RECEIPT.json','DERIVATION.json','V2-DERIVATION.json']:items[n]=src/n + for n in ['lift_parent.py','replica_parent.py','reconstruct_replica.py']:items['helpers/'+n]=a.retained/'helpers'/n + for n,f in [('extension_blocknorm.py',a.retained/'adapters/extension_blocknorm.py'),('PR2969-CLAIM.json',a.retained/'PR2969-CLAIM.json'),('FILL.json.gz',a.fill),('ORDER.json',a.allocation/'ORDER.json'),('DISPATCH.json',a.allocation/'DISPATCH.json')]:items[n]=f + for n in ['admit.py','NATIVE-RECEIPT.json','source/MANIFEST.json','source/verify.py','source/new/rebuild_borrow.py','source/new/borrow/review_staged3605.py']:items['_provenance/v1/'+n]=a.predecessor/n + manifest={n:sha(f) for n,f in sorted(items.items())};archive=P/'REPLAY-INPUTS.tar.gz';tmp=P/'REPLAY-INPUTS-new.tar.gz' + with tarfile.open(tmp,'w:gz',compresslevel=9) as tf: + for n,f in sorted(items.items()): + info=tf.gettarinfo(str(f),arcname=n);info.uid=info.gid=0;info.uname=info.gname='';info.mtime=0 + with f.open('rb') as stream:tf.addfile(info,stream) + tmp.replace(archive) + (P/'REPLAY-INPUTS.json').write_text(json.dumps(dict(archive_sha256=sha(archive),files=manifest,scope='Self-contained exact v2 input/source export. Includes exact v1 source manifest and all differing v1 source files/driver/receipt, so the preparatory reuse source tree can be reconstructed without private caches or Git. Explicit retained native/parent reuse, current changed native fresh in this session.'),indent=2)+'\n');print(archive.stat().st_size,len(items)) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/finish_v2.py b/research/staged-donor-release/finish_v2.py new file mode 100644 index 0000000000..b6fd1177a0 --- /dev/null +++ b/research/staged-donor-release/finish_v2.py @@ -0,0 +1,44 @@ +"""Resume after a declared-edit binding repair; do not erase first failure. +Unchanged preparatory discovery is reused by exact source-change coverage. +The complete original release (including strict global admission) runs fresh. +""" +from pathlib import Path +from fractions import Fraction as Q +import argparse,hashlib,json,os,shutil,subprocess,sys,time +P=Path(__file__).parent +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_text()) +def tree(p):return {f.relative_to(p).as_posix():sha(f) for f in sorted(p.rglob('*')) if f.is_file() and f!=p/'MANIFEST.json'} +def write(p,x):p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n') +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--admission',type=Path,required=True);ap.add_argument('--inputs-v1',type=Path,required=True);ap.add_argument('--inputs-v2',type=Path,required=True);a=ap.parse_args();work=a.admission.resolve();v1=a.inputs_v1.resolve();v2=a.inputs_v2.resolve();package=work/'package' + assert __debug__ and tree(v1/'source')==read(v1/'source/MANIFEST.json') and tree(v2/'source')==read(v2/'source/MANIFEST.json') + deriv=read(v2/'V2-DERIVATION.json');assert deriv['modified_files']==['new/borrow/review_staged3605.py','new/rebuild_borrow.py','verify.py'] + assert set(deriv['added_files'])=={'new/borrow/delay_applier.py','new/borrow/review_delayed.py','new/borrow/delayed/PR3605-base.json.gz','new/borrow/delayed/PR3605-extra.json.gz'} + assert tree(package)==read(package/'MANIFEST.json') + stages=read(work/'STAGES.json');expected=['owners','parent-lift','rebind','discovery','outer-check_ledger.py','outer-independent_check.py','release'];assert [s['name'] for s in stages]==expected and [s['exit_code'] for s in stages]==[0,0,0,0,0,0,1] + for s in stages: + assert sha(work/(s['name']+'.log'))==s['log_sha256'] and sha(Path(s['command'][2]))==s['script_sha256'] + failed=(work/'release/verify/rebuild-borrow-words.log').read_text();assert "'rebuild_plus_patches_equals_shipped': False" in failed and 'FAIL_REBUILD_BORROW' in failed + assert read(work/'discovery/RESULT.json')['status']=='DISCOVERY' and all(z['exit_code']==0 for z in read(work/'discovery/RESULT.json')['steps']) + # Changed files are only release reconstruction entry points; none is imported + # by owners/parent-lift/rebind/discovery/outer checks. Every native source, + # provider word, fill, scientific engine and corresponding code remains exact. + coverage=dict(status='AUTHENTICATED_PREPARATORY_STAGE_REUSE_AFTER_DECLARED_EDIT_BINDING_REPAIR',source_manifest_v1=sha(v1/'source/MANIFEST.json'),source_manifest_v2=sha(v2/'source/MANIFEST.json'),derivation_sha256=sha(v2/'V2-DERIVATION.json'),reused_stages=stages[:-1],failed_stage=stages[-1],first_failure_scope='Declared reconstruction stops at PR3605; actual native endpoint/control checks passed but byte-for-content equality correctly fails.',source_changed_files=deriv['modified_files'],source_added_files=deriv['added_files'],native_scientific_words_and_engines_unchanged=True,fresh_stage='Entire original verify_release.py with all native binding/rebuild/independent/strict/outer/control stages; retained parent/native evidence remains explicit reuse.') + write(work/'V2-REUSE-COVERAGE.json',coverage) + for rel in deriv['added_files']+['new/rebuild_borrow.py','new/borrow/review_staged3605.py']: + dst=package/rel;dst.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(v2/'source'/rel,dst) + # Preserve every existing runtime patch to verify.py while appending one hook. + entry=next(r for r in deriv['patches'] if r['path']=='verify.py');before,after=entry['replacement'];text=(package/'verify.py').read_text();assert text.count(before)==1;(package/'verify.py').write_text(text.replace(before,after)) + write(package/'MANIFEST.json',tree(package)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1');env.pop('PYTHONOPTIMIZE',None);env.pop('PYTHONPATH',None) + out=work/'release-v2';assert not out.exists();cmd=[sys.executable,'-B',str(package/'verify_release.py'),'--main',str(v2),'--work',str(out),'--native-cache',str(v2/'native-cache'),'--jobs','1'];start=time.monotonic() + with (work/'release-v2.log').open('w') as log:r=subprocess.run(cmd,env=env,stdout=log,stderr=subprocess.STDOUT) + finalstage=dict(name='release',command=cmd,script_sha256=sha(package/'verify_release.py'),log_sha256=sha(work/'release-v2.log'),exit_code=r.returncode,seconds=time.monotonic()-start) + write(work/'V2-STAGES.json',stages[:-1]+[finalstage]);assert r.returncode==0,'see release-v2.log' + result=read(work/'RESULT.json');receipt=read(out/'RELEASE-RECEIPT.json');C=Q(read(package/'new/SPEC.json')['expected']['complex_lower']);K=C-Q(1,10**46)-Q(1,10**70) + assert receipt['status']=='PASS_RELEASE' and Q(receipt['kappa_decimal'])==K and receipt['manifest_sha256']==sha(package/'MANIFEST.json') + assert result['profile']==read(P/'LEAD1-PRICE.json')['profile'] and C==Q(read(P/'LEAD1-PRICE.json')['root_interval'][0]) and K>Q(read(P/'sources/T360-PRICE.json')['root_interval'][1]) + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE',source_manifest_sha256=sha(v2/'source/MANIFEST.json'),source_file_count=652,native_receipt_sha256=sha(v2/'NATIVE-RECEIPT.json'),complex_lower=str(C),kappa=str(K),kappa_decimal=receipt['kappa_decimal'],release_receipt_sha256=sha(out/'RELEASE-RECEIPT.json'),package_manifest_sha256=sha(package/'MANIFEST.json'),stages=stages[:-1]+[finalstage],source_reconstruction_binding_repair=True,reuse_coverage_sha256=sha(work/'V2-REUSE-COVERAGE.json'),scope='Conditional finite construction and complete modern outer arithmetic. Preparatory discovery reused under exact source-change coverage; entire original release rerun after adding declared retiming stage. Both current native chains freshly executed earlier in this session; unchanged retained native/parent evidence explicitly reused. Inherited theorem hypotheses remain.') + write(work/'RESULT-v2.json',result);print(result['status'],result['kappa_decimal'],flush=True) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/full_replay.py b/research/staged-donor-release/full_replay.py new file mode 100644 index 0000000000..4d50cc9014 --- /dev/null +++ b/research/staged-donor-release/full_replay.py @@ -0,0 +1,57 @@ +"""Portable complete release; fresh changed providers, explicit retained parent reuse.""" +from pathlib import Path +import argparse,gzip,hashlib,json,os,shutil,subprocess,sys,tarfile +P=Path(__file__).resolve().parent + +def need(ok,msg): + if not ok:raise ValueError(msg) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +def tree(p,exclude=()):return {f.relative_to(p).as_posix():sha(f) for f in sorted(p.rglob('*')) if f.is_file() and f.relative_to(p).as_posix() not in exclude} +def write(p,x):p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n') +def extract(target): + pins=read(P/'REPLAY-INPUTS.json');archive=P/'REPLAY-INPUTS.tar.gz';need(sha(archive)==pins['archive_sha256'],'source archive pin');target.mkdir() + with tarfile.open(archive) as tf: + names=set() + for m in tf: + need(m.isfile() and m.name in pins['files'] and m.name not in names and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts,'source member') + raw=tf.extractfile(m).read();need(hashlib.sha256(raw).hexdigest()==pins['files'][m.name],'source member hash');names.add(m.name);f=target/m.name;f.parent.mkdir(parents=True,exist_ok=True);f.write_bytes(raw) + need(names==set(pins['files']),'complete source archive') + if (target/'V2-DERIVATION.json').exists(): + deriv=read(target/'V2-DERIVATION.json');v1=target/'_provenance/v1/source';oldmanifest=read(v1/'MANIFEST.json') + need(sha(v1/'MANIFEST.json')==deriv['old_manifest'],'reused source predecessor manifest') + current=read(target/'source/MANIFEST.json');need(set(current)-set(oldmanifest)==set(deriv['added_files']),'source addition coverage') + for rel,h in oldmanifest.items(): + source=(v1/rel) if rel in deriv['modified_files'] else (target/'source'/rel) + need(sha(source)==h,'reconstructed exact preparatory source '+rel) + return target + +def main(): + need(__debug__,'enabled assertions required');ap=argparse.ArgumentParser();ap.add_argument('--work',type=Path,required=True);ap.add_argument('--reuse-current-native',action='store_true');ap.add_argument('--extract-only',action='store_true');a=ap.parse_args();work=a.work.resolve();need(not work.exists(),'fresh output required');work.mkdir();inputs=extract(work/'inputs') + if a.extract_only:print('PASS_SELF_CONTAINED_SOURCE_EXPORT');return + source=inputs/'source';cache=inputs/'native-cache';receipt=read(inputs/'NATIVE-RECEIPT.json');stages=[] + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1',PYTHONINTMAXSTRDIGITS='0');env.pop('PYTHONOPTIMIZE',None) + # Platform-neutral scientific command; optional APFS adapter only affects copies. + env.pop('PYTHONPATH',None) + def run(name,cmd): + with (work/(name+'.log')).open('w') as log:r=subprocess.run(cmd,env=env,stdout=log,stderr=subprocess.STDOUT,stdin=subprocess.DEVNULL) + stages.append(dict(name=name,command=cmd,exit_code=r.returncode,log_sha256=sha(work/(name+'.log'))));write(work/'STAGES.json',stages);need(r.returncode==0,'failed '+name+'; see '+str(work/(name+'.log')));print('PASS',name,flush=True) + if not a.reuse_current_native: + fresh=work/'native-cache';fresh.mkdir();newkeys={v['word_sha256'] for v in receipt['providers'].values()} + for f in cache.iterdir(): + if f.name not in newkeys:shutil.copytree(f,fresh/f.name) + for tag in ('base','extra'): + word=source/'new/borrow/words'/f'BORROW-WORD-43{tag}.json.gz';out=work/('native-'+tag);run('fresh-native-'+tag,[sys.executable,'-B',str(source/'new/fastnative/run_native.py'),str(word),str(out)]) + res=read(out/'RESULT.json');need(res['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY' and res['word_sha256']==sha(word),'fresh native result');need(res['source_sha256']==read(P/'evidence'/('native-'+tag)/'RESULT.json')['source_sha256'],'same native scientific engine') + entry=fresh/sha(word);shutil.copytree(out/'native',entry);write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry)));receipt['providers'][tag]=dict(word_sha256=sha(word),complete_native_files=tree(entry,('CACHE.json',))) + cache=fresh;receipt['cache_files']=tree(cache) + native_receipt=work/'NATIVE-RECEIPT.json';write(native_receipt,receipt) + cmd=[sys.executable,'-B',str(inputs/'admit.py')] + for k,v in {'source':source,'fill':inputs/'FILL.json.gz','order':inputs/'ORDER.json','dispatch':inputs/'DISPATCH.json','native-cache':cache,'native-receipt':native_receipt,'work':work/'admission','replica-helper-dir':inputs/'helpers','reconstructor':inputs/'helpers/reconstruct_replica.py','comparison-claim':inputs/'PR2969-CLAIM.json','blocknorm-checker':inputs/'extension_blocknorm.py'}.items():cmd+=['--'+k,str(v)] + cmd+=['--source-profile','staged3605','--comparison-profile','pr2969','--jobs','1'];run('complete-admission',cmd) + result=read(work/'admission/RESULT.json');need(result['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE','complete release');need(result['profile']==read(P/'LEAD1-PRICE.json')['profile'],'exact full profile') + from fractions import Fraction as Q + exp=Q(read(P/'LEAD1-PRICE.json')['root_interval'][0])-Q(1,10**46)-Q(1,10**70);need(Q(result['kappa'])==exp,'exact endpoint');need(exp>Q(read(P/'sources/T360-PRICE.json')['root_interval'][1]),'strict current comparator gain') + write(work/'RESULT.json',dict(status='PASS_DELAYED_RELEASE_COMPLETE_CONDITIONAL_RELEASE',kappa=str(exp),kappa_decimal=result['kappa_decimal'],reuse_current_native=a.reuse_current_native,retained_parent_reused=True,source_archive_sha256=sha(P/'REPLAY-INPUTS.tar.gz'),release_receipt_sha256=sha(work/'admission/release/RELEASE-RECEIPT.json'),scope=result['scope'])) + print('PASS_DELAYED_RELEASE_COMPLETE_CONDITIONAL_RELEASE',result['kappa_decimal']) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/invoice.py b/research/staged-donor-release/invoice.py new file mode 100644 index 0000000000..47de17441b --- /dev/null +++ b/research/staged-donor-release/invoice.py @@ -0,0 +1,69 @@ +"""Exact source patch, scalar identity and literal frame invoice. +Adapted from a separate OpenAI Codex review by Ross Richardson. +Assertions must remain active; the public driver starts this in an unoptimized +child interpreter with an isolated bytecode-cache namespace.""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter,defaultdict +from functools import lru_cache +import gzip,hashlib,json,sys +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +SRC=ROOT/'research/rank7-coupled-586-588-carrier-fold/edits' +@lru_cache(None) +def span(xs): + a={0} + for x in xs:a|={v^x for v in tuple(a)} + return frozenset(a) +def dim(s): + d=len(s).bit_length()-1;assert len(s)==1<0 + minimum=low if minimum is None else min(low,minimum) + assert (patterns,tight)==(2551,12) + return dict(patterns=patterns,symbolic_tight=tight,minimum_strict_lower=R.compact((minimum,minimum))['lower'],scope='Old capacity and pattern alphabet, evaluated at stated K; not a dual for arbitrary changed widths.') +def main(): + # Per-call unchanged-inventory LP sensitivity: no capacity RHS delta. + delta={1:-2,2:-2,3:2};assert sum(r*n for r,n in delta.items())==0 + change=R.interval(delta,K);assert change[1]<0 + # Prior PR3605 calibration, times20 to keep integer coefficients. + shadow=R.interval({5:-5,48:1,3:-1},K) + old=R.interval({1:60,2:20,3:-41,5:-5,48:1},K) #10*(6H1+2H2-4H3 +2shadow/20) + assert old[1]<0 + h={int(r):n for r,n in json.loads((P/'sources/T360-PRICE.json').read_text())['profile'].items()} + for r,n in delta.items():h[r]+=9*360*n + out=dict(dual=dual_check(),status='PASS_EXACT_LOCAL_AND_FIXED_ALLOCATION_PRICE',k=str(K),local_delta=R.compact(change),width8_to7_shadow_times20=R.compact(shadow),prior_staged_net_times10=R.compact(old),profile=h,root_interval=bracket(h,'0.001730418899766071163804','0.001730418899766071163805'),scope='Exact finite paid profile using unchanged T360 idle and private stock. No native, physical ordinary/outer admission follows from these inequalities.') + print(json.dumps(out,indent=2)) +if __name__=='__main__':main() diff --git a/research/staged-donor-release/reviews/lead1/CHECK.json b/research/staged-donor-release/reviews/lead1/CHECK.json new file mode 100644 index 0000000000..95192e81dd --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/CHECK.json @@ -0,0 +1,61 @@ +{ + "status": "PASS_INDEPENDENT_STRUCTURAL_CERTIFICATE", + "python": "3.12.8 (main, Dec 7 2024, 10:11:37) [Clang 15.0.0 (clang-1500.3.9.4)]", + "scope": "Exact commuting proof on arbitrary full dirty states; inverse transpose follows from equality of invertible operators. Independently reconstructed cleanup and donor invoices. Does not replay native or outer admission.", + "checks": [ + { + "provider": "base", + "checks": [ + { + "start": 591, + "stop": 1045, + "exact_commutators": 453, + "crossed_warps_including_stop_cut": 30 + }, + { + "start": 641, + "stop": 1085, + "exact_commutators": 443, + "crossed_warps_including_stop_cut": 36 + } + ], + "changed_wire_bills": [ + 640, + 656 + ], + "delta": { + "1": -2, + "2": -2, + "3": 2 + }, + "native_word_hash_matches": true + }, + { + "provider": "extra", + "checks": [ + { + "start": 591, + "stop": 1045, + "exact_commutators": 453, + "crossed_warps_including_stop_cut": 30 + }, + { + "start": 641, + "stop": 1085, + "exact_commutators": 443, + "crossed_warps_including_stop_cut": 36 + } + ], + "changed_wire_bills": [ + 640, + 656 + ], + "delta": { + "1": -2, + "2": -2, + "3": 2 + }, + "native_word_hash_matches": true + } + ] +} diff --git a/research/staged-donor-release/reviews/lead1/CONCURRENCY-CHECK.json b/research/staged-donor-release/reviews/lead1/CONCURRENCY-CHECK.json new file mode 100644 index 0000000000..25fe4d8e1b --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/CONCURRENCY-CHECK.json @@ -0,0 +1,35 @@ +{ + "status": "PASS_SCOPED_CONCURRENCY_RECONCILIATION", + "documentation_commit": "2b0c3deffe4ff261e7f36826299b264b81b2c39c", + "scientific_commit": "a3bdc591920a4b9003d8442d1fcca24218153661", + "reported_pr3642_head": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "reported_pr3653_head": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "rank_cross_products_equal": true, + "profiles": { + "T360": { + "1": 7980120, + "2": 2345760, + "3": 755730, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "T488": { + "1": 10817496, + "2": 3179808, + "3": 1024434, + "4": 447984, + "5": 94794, + "8": 35136, + "48": 186782 + } + }, + "physical": { + "T360": 323069, + "T488": 437757 + }, + "common_endpoint": "0.001730418899766071163804 - 10^-46 - 10^-70", + "old_baseline_gain": "0.000000322536237447629574", + "scope": "Exact arithmetic on retained public claims, live heads checked separately; no independent replay or scientific approval of concurrent PRs." +} diff --git a/research/staged-donor-release/reviews/lead1/PRICE.json b/research/staged-donor-release/reviews/lead1/PRICE.json new file mode 100644 index 0000000000..ae417c0ec5 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/PRICE.json @@ -0,0 +1,36 @@ +{ + "dual": { + "patterns": 2551, + "symbolic_tight": 12, + "minimum_strict_lower": "4053468025645212954130191300621690725601209608148213926713/1000000000000000000000000000000000000000000000000000000000000", + "scope": "Old capacity and pattern alphabet, evaluated at stated K; not a dual for arbitrary changed widths." + }, + "status": "PASS_EXACT_LOCAL_AND_FIXED_ALLOCATION_PRICE", + "k": "173009636352862353423/100000000000000000000000", + "local_delta": { + "lower": "-3299714488759840734997518419826012212910695186919289400037/500000000000000000000000000000000000000000000000000000000000", + "upper": "-6599428977519681469995036839652024425821390373838578800073/1000000000000000000000000000000000000000000000000000000000000" + }, + "width8_to7_shadow_times20": { + "lower": "246935045936431659522948237548685897943499745459984726817273/12500000000000000000000000000000000000000000000000000000000", + "upper": "19754803674914532761835859003894871835479979636798778145381841/1000000000000000000000000000000000000000000000000000000000000" + }, + "prior_staged_net_times10": { + "lower": "-65268039542568976533836655295640969913942214558880321551831/1000000000000000000000000000000000000000000000000000000000000", + "upper": "-6526803954256897653383665529564096991394221455888032155183/100000000000000000000000000000000000000000000000000000000000" + }, + "profile": { + "1": 7980120, + "2": 2345760, + "3": 755730, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "root_interval": [ + "0.001730418899766071163804", + "0.001730418899766071163805" + ], + "scope": "Exact finite paid profile using unchanged T360 idle and private stock. No native, physical ordinary/outer admission follows from these inequalities." +} diff --git a/research/staged-donor-release/reviews/lead1/REVIEW-CONCURRENCY.md b/research/staged-donor-release/reviews/lead1/REVIEW-CONCURRENCY.md new file mode 100644 index 0000000000..c87c1da3f2 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/REVIEW-CONCURRENCY.md @@ -0,0 +1,32 @@ +# Scoped concurrency reconciliation review + +CONCLUDE: YES +OUTCOME: SUCCESS_KAPPA — conditional gain over the old pinned PR3638/PR3633 baseline; matches the currently reported concurrent endpoint, with smaller T360 stock. No additional frontier gain or priority claim. +PRESENTATION ARTIFACT: 2b0c3deffe4ff261e7f36826299b264b81b2c39c +ORIGINAL SCIENTIFIC ARTIFACT: a3bdc591920a4b9003d8442d1fcca24218153661 + +This is a factual upstream-reconciliation follow-up to my independent scientific review, not a new scientific approval of either concurrent PR. No external posts or PRs were created and no heavy replay was launched. + +## Findings + +Reviewed all six paths changed by the presentation commit: CONCURRENT-WORK.md, README.md, PR-DRAFT.md, TASK.json, evidence/concurrent/3642.json and evidence/concurrent/3653.json. Live GitHub API reads independently confirmed the retained heads: PR3642 at 044d24f12e74f228dd462c07ae2d7f3ea35e2be9 and PR3653 at 607a09ff441c79b215a8127a81f4cc70021d0d9b. Their retained bodies support the reported mechanism, endpoints, T values and finite stock counts. The public claims remain provisional external evidence; their full scientific releases were not independently replayed here. + +A fresh exact integer/Fraction check extracted PR3653's stated profile and checked every rank cross-product: + +h488[r]*360 = h360[r]*488, for ranks 1,2,3,4,5,8,48. + +Thus the normalized profiles agree exactly; there is no exponent gain from this T360 composition over that reported T488 construction. The common conditional endpoint is .001730418899766071163804−10^-46−10^-70. The exact common-grid gain over the old pinned .001730096363528623534230 predecessor is .000000322536237447629574. PR3642's reported .001730394391813963415120 endpoint is lower by .000000024507952107748684. + +The smaller finite constants are correctly stated: physical stock 896*360+408+8+91+2 = 323069 versus 896*488+408+8+91+2 = 437757; calls 3240 versus 4392; roles 1321920 versus 1791936. Stock reduction is not a further normalized exponent improvement. Evidence: CONCURRENCY-CHECK.json. + +The presentation explicitly credits the concurrent retiming mechanism and T488 endpoint, identifies the result as matching that endpoint with smaller stock, and limits its strict-gain comparison to the old pinned baseline. This is an appropriate revision of the claim. I do not treat the broader overlap search's pagination counts as a novelty certificate or as independently verified source-diff coverage. + +I also compared the package to the original approved scientific commit. Subsequent changes are presentation, validation/review records, the new concurrent metadata and reviewer artifacts; no scientific source, source archive, candidate word, native/complete receipt, mathematical price, or execution engine changed. The PROOF edits since original approval merely record that approval. The original scientific conclusion and its explicit reuse/cold-run limitations therefore remain applicable. + +## Critical gaps + +None blocking the revised scoped conclusion. This approval does not establish that PR3653 has itself met every admission obligation; it establishes exact agreement with its reported normalized profile and endpoint, with that qualification preserved in the package. + +## Remaining open domain + +All inherited theorem assumptions and unexecuted portable/no-reuse cold tails remain as recorded in REVIEW-TERMINAL.md. No selected-frontier update, global optimum, priority, novel retiming discovery, or improvement beyond PR3653's reported endpoint is approved. Publication and any subsequent upstream changes remain outside this exact-commit review. diff --git a/research/staged-donor-release/reviews/lead1/REVIEW-TERMINAL.md b/research/staged-donor-release/reviews/lead1/REVIEW-TERMINAL.md new file mode 100644 index 0000000000..6d4eee67af --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/REVIEW-TERMINAL.md @@ -0,0 +1,41 @@ +# Independent terminal lead1 review + +CONCLUDE: YES +OUTCOME: SUCCESS_KAPPA +ARTIFACT: a3bdc591920a4b9003d8442d1fcca24218153661 + +Approval is for the complete conditional finite construction at this exact commit and its focused contribution. It is not unconditional multiplication-theorem verification, a selected-frontier update, a human review, or approval of other campaign leads. + +The final artifact differs from scientifically checked 6ab8f400577a749c80d1236b3957b4f54fa6c2ff only by 13 reviewed explanatory lines in PROOF.md. They correctly distinguish the online endpoint and historical prose from the modern numeric release. No source, evidence or executable changed. + +## Result and evidence + +The authenticated complete original release supports + +κ = 0.001730418899766071163804 − 10^-46 − 10^-70. + +On the common release grid this exceeds pinned PR3638/PR3633 by 0.000000322536237447629574. It also exceeds the pinned comparator's upper root endpoint, even after the new backoffs. The selected result remains unchanged. + +I freshly ran the bounded evidence checker and all nine semantic receipt controls; both passed. I also authored and ran `check_terminal.py`, which independently checks exact inventory completeness and every retained file hash; binds every logged STRICT and VERIFY stage to its stored log; binds all seven top-level stages to logs and actual runtime script hashes; matches source/native words to the already reviewed portable archive; matches the actual full profile across price, RESULT, independent global audit, assembly and outer ledger; reconstructs that profile from local charges plus idle; verifies physical stock and exact precision arithmetic; and verifies the complex/BIT endpoints and exact modern outer backoffs. Receipt: TERMINAL-CHECK.json. This was Python 3.12.8, assertions enabled, and no new heavy replay. + +The archive is byte-identical to the source closure reviewed at 29b904054c67a40b140806698398a4af547f1d03: SHA256 fa4222b179c2b16c197620c4000781faa5f2364384e60ef623a95e88487677c8. The native words are unchanged. Thus the earlier independent exact commuting/cleanup/frame-invoice proof and complete v1/v2 source-closure checks still apply. The package rename does not alter those mathematical inputs. + +The original repaired release now supplies the missing terminal evidence. Source reconstruction includes both PR3605's frozen intermediate review and the distinct delayed-release independent review. The original strict sequence bind/emit/audit/invoice/assembly/admission/bit/independent passed. The stored independent global audit checks all 1,321,920 roles, whole-helper widths and busy-family windows, under the actual changed local profile. Physical stock is exactly 896*360+408+8+91+2 = 323,069. The full profile is {1:7980120,2:2345760,3:755730,4:330480,5:69930,8:25920,48:137790}, with rank mass 65088*360. + +Precision is explicit: actual prefix 95+37+18+1323+1+4 = 1478, sufficient reserve 128+37+18+1323+1+4 = 1511, paid 2048. The block certificate includes full physical stock, actual dirty endpoints in both orientations, eight centres and 91 private buffers. The unchanged BIT lower endpoint exceeds the complex endpoint. The modern outer ledger binds the complex moment and final κ; its exact displayed margins are positive and its 17 rejecting controls are retained. The earlier outer/discovery execution is explicitly reused under exact unchanged-code/data coverage; the entire repaired release ran freshly. + +## Interpretation caveats, not scientific blockers + +The stored STRICT/VERIFY/ASSEMBLY `kappa` field is the inherited online endpoint .001727429722725848. The assembly `complex_lower`, modern OUTER-LEDGER and final RELEASE/RESULT establish the larger stated conditional κ. These fields describe different composition stages and should not be equated. + +Likewise, OUTER-CLAIM's inherited branch prose still refers to 3000-digit/e-3080 historical settings. Its retuned-slack fields, actual rational ledger and final release use precision24 and e-104. The final PROOF.md now correctly explains this template-prose distinction while preserving frozen receipts. The final exact numerical checks, rather than stale explanatory strings, support the claim. + +## Critical gaps + +None blocking this scoped conditional finite result. The previous blockers—complete terminal evidence and durable source closure—are repaired. The portable default CLI's full end-to-end tail and the no-reuse retained-parent cold CLI remain unexecuted and accurately disclosed; approval does not relabel them as completed. Earlier preparatory discovery/outer and retained parent/native reuse remain explicit. Publication/hosted CI is subsequent work and is not certified by this local review. + +## Remaining open domain + +The exact two commuting shifts have been verified; compensated releases after pivot changes, joint consumers, alternative frame choices and other constructions remain unexhausted. No missed applicable universal cap or necessary search direction was identified that should prevent releasing this finite improvement. PR3562's ordinary physical route is not a universal cap here. + +All-size compiler, uniform/common-label mutable-source realization, whole-call hosting, recursive precision/tape/recovery, bootstrap and analytic/BIT H1-H5 remain inherited assumptions. This conditional success does not prove those assumptions or a complete integer multiplication theorem. The other three research leads are outside this terminal approval. diff --git a/research/staged-donor-release/reviews/lead1/REVIEW-V2.md b/research/staged-donor-release/reviews/lead1/REVIEW-V2.md new file mode 100644 index 0000000000..1847dcaf40 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/REVIEW-V2.md @@ -0,0 +1,33 @@ +# Independent lead1 integration/source-reuse review + +CONCLUDE: CONTINUE +OUTCOME: LOCAL_PROGRESS +ARTIFACT: 29b904054c67a40b140806698398a4af547f1d03 + +The source-closure and declared-stage repair passes this bounded review. This is not terminal approval of the complete conditional κ release. No complete admission suite was launched here, and no frozen source bytes were edited. + +## Fresh checks + +New independent `check_v2_closure.py` reads the archive directly, without importing the production extractor. It authenticates all 734 member hashes and the archive hash, reconstructs every original v1 manifest entry, verifies all 652 v2 manifest entries, and proves that the complete difference consists of exactly three changed files and four additions with no deletions. Each declared replacement is checked byte-for-byte against both versions; the admission driver changes only the source manifest and file count. Both intermediate PR3605 snapshots and actual candidate words equal the already reviewed frozen inputs. Mathematical helper functions in the integrated independent checker equal the original reviewer code. + +Replay: `/tmp/three-kappa-env/bin/python -B research/four-kappa-leads/reviews/lead1/check_v2_closure.py`; receipt V2-CLOSURE.json. The archive SHA256 is fa4222b179c2b16c197620c4000781faa5f2364384e60ef623a95e88487677c8. `full_replay.py --work /tmp/lead1-review-v2-export --extract-only` also passed from the committed portable archive. + +Fresh bounded executions of the exported PR3605 staged reconstruction/control and delayed-release independent review passed; see V2-STAGED.log and V2-DELAYED.json. `owner_transfer.py /tmp/lead1-review-v2-export/inputs` passed; V2-OWNER-TRANSFER.json records its result. These runs use Python 3.12.8 with assertions enabled. The owner transfer is explicitly authenticated journal reuse, not a fresh 1,321,920-row replay. + +## Scope analysis + +The former reconstruction mismatch is repaired honestly. PR3605's original checker still tests the PR3605 stage and its rejection control against exact historical snapshots. The inherited reconstruction chain appends the new retiming stage, and the release orchestrator appends a distinct independent structural review without removing any original run. The applier's declared bill is a constant, but independent donor billing and the native invoice check it; it is not accepted solely on its own assertion. The destination-cut warp guard is now present. + +The exact source difference does not alter any provider word, native engine, owner reconstruction, discovery replay, outer arithmetic or cost data. The discovery runtime is populated from unchanged replay/scientific files and candidate/native data; the three modified files are release reconstruction/review entry points. Reusing its authenticated earlier successful discovery and outer stages is therefore scoped to unchanged computations. `finish_v2.py` preserves the failed first release and reruns the entire original release, including strict global checking, rather than treating repaired reconstruction alone as admission. + +The owner transfer compares actual helper entrance and terminal subspaces, helper identities and zero-buffer inventory for both providers; it binds order/dispatch and the fill payload, and recomputes the complete bill from the new local profile plus retained idle costs. This is stronger than matching a width histogram alone. Fixed whole-call ownership/chronology and identical endpoints justify the local transfer; actual global checking in terminal admission remains a separate obligation. The script's comment about dispatch_overrides is imprecise: the enforced payload relation here is exact equality up to the final LF, so it does not silently authorize arbitrary override changes. + +One hardening opportunity remains: `finish_v2.py` validates the asserted change lists and each source's own manifest, but does not itself compute that the actual old/new manifest difference equals those lists or that the v2 files equal the declared replacements. My new independent closure check supplies precisely that verification for this frozen artifact. Add equivalent assertions to the generic resume helper before reusing it for a different repair; this does not invalidate the present pinned repair. + +## Critical gaps and next approval boundary + +Terminal strict/global/outer release receipts and final margins were not frozen at this commit. Retain the first failure and final successful release, authenticate V2-REUSE-COVERAGE and stage logs against the actual runtime package, and bind final profile, endpoint/backoffs and source manifest. Freeze the successful evidence at a new exact commit for renewed review. The durable portable source-closure gap from the earlier review is repaired; terminal evidence remains the blocker. + +## Remaining open domain + +The no-reuse retained-parent cold CLI remains unrun and must remain explicitly disclosed. The separate current-provider native runs and inherited parent reuse are different coverage claims. All-size compiler, hosting/source realization, recursive precision/tape/recovery, bootstrap and analytic/BIT H1-H5 remain inherited conditional premises. No universal optimum, full multiplication theorem, or selected-frontier update follows from this integration review. diff --git a/research/staged-donor-release/reviews/lead1/REVIEW.md b/research/staged-donor-release/reviews/lead1/REVIEW.md new file mode 100644 index 0000000000..6777ae2d7d --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/REVIEW.md @@ -0,0 +1,33 @@ +# Independent AI review of lead1 + +CONCLUDE: CONTINUE +OUTCOME: LOCAL_PROGRESS +ARTIFACT: b4ee5eee2e4e8ad2f91bf128858e14b5d6da1b57 + +Reviewed frozen candidate, not a later admission result. AI review, not human or formal-kernel review. No frozen inputs were edited. New independent check and receipts are in this directory. + +## Evidence and result + +`/tmp/three-kappa-env/bin/python -B research/four-kappa-leads/reviews/lead1/check.py` passed on Python 3.12.8. This checker imports neither the candidate builder nor its invoice. It authenticates every SOURCE-PINS entry, independently relocates the two literal releases, preserves complete frames and warp identities, reconstructs inverse cleanup, and derives per-register frame charges. Per provider it checks 453 and 443 intervening elementary matrices by exact Fraction multiplication and 30 and 36 native warp events for disjoint support. It includes warps at the destination cut, which the candidate builder's local guard excludes. These actual source words pass that stronger check. The guard omission is a future-generalization weakness, not a counterexample to this pinned candidate. + +The commuting argument is exact: a release I+qE[d,h] commutes with every crossed elementary operator (including permitted writes into d and reads from h); disjoint native warps commute as tensor operators. Other event order and native operator IDs remain intact. Thus the full products are equal on arbitrary independent dirty coordinates, not merely zero-helper starts. Taking inverse transpose preserves equality. The cleanup is independently reconstructed with buffer relabeling and exact signed warp identities. This structural argument proves equivalence to the predecessor; predecessor endpoint correctness and native implementation remain inherited obligations, supported by the retained native receipts rather than freshly re-executed here. + +Only donor 640 and donor 656 change frame bills, each by -H1-H2+H3. Other frame bills and non-B/non-cleanup fields are unchanged; the helper entrance/terminal data and private stock stay fixed. Private center descents are unchanged because cut/center/target-level data are identical. The complete local delta is therefore 2H3-2H2-2H1. Strict subadditivity for exponent 1-k in (0,1) proves its favorable sign independently of root extraction. The native receipt word digests match both actual candidate words. Retained native LOCAL-CHECKS cover 632 columns in both orientations and 91 zero buffers, but this is not a fresh independent native replay. + +The bounded `price.py` replay passed; PRICE.json records the exact 2,551-pattern / 12-tight-equality calibration and profile root bracket [.001730418899766071163804,.001730418899766071163805]. Unchanged widths mean the old primal packing remains a constructive cost bound, subject to the actual complete source/owner admission. The old dual is not by itself a new global construction or universal ceiling. + +## Comparator and novelty + +A live GitHub API read during review confirmed PR3638 remains open at d62e1acd7518a231440383f0d0dddf54d6edf8c1. The comparison is to its conditional .001730096363528623534230 endpoint minus release backoffs, not just to selected .001672660197076918. The new endpoint is larger, conditional on completing the same admissibility chain. PR3562's distinct ordinary physical route is not a universal cap on this construction. + +Read discussion 1163 and the active discussion list, then 3606 and its recent comments. A live advisory independent audit of PR3605's existing staged words is at discussioncomment-19017456; it is adjacent work, not this late-release edit. The retained initial overlap report's four query terms do not establish novelty for delayed release scheduling, and its one hit must not be described as exhaustive source-level novelty. Credit to the staged-word and T360 packing predecessors remains essential. No newly observed competing result in this bounded read changes the stopping decision. + +## Critical gaps and exact repair + +1. Frozen candidate has no completed all-gate original T360 admission receipt. At inspection the live RAM log reports only owners, parent-lift, rebind. Complete the current run, freeze successful receipts and final strict margins, and record every reused versus freshly executed gate. A passing local word/profile is insufficient for SUCCESS_KAPPA. +2. Export the complete source-bound candidate and required admission evidence from the temporary RAM volume into durable artifacts, authenticate manifests and source bytes, and bind the final paid profile, both native words, actual T360 primal/chronology, physical stock, precision, outer transfer and release backoffs. Check a clean exported replay or explicitly document bounded authenticated reuse and remaining cold obligations. +3. Recheck comparator heads and targeted scheduling overlap before publication; preserve provenance and notices. Freeze a new exact commit and request renewed review of the completed release. Current approval is only for the scoped local equivalence/cost result. + +## Remaining open domain + +The checked domain is exactly two commuting shifts on the pinned staged words with all other releases fixed. Compensated shifts after pivot updates, joint consumer changes, and other frames were not exhausted. No optimality or universal barrier is justified. These open directions do not require further research to validate this local delta; the immediate stopping blocker is release evidence. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape/recovery, bootstrap, and analytic/BIT H1-H5 remain conditional inherited premises even after finite admission succeeds. diff --git a/research/staged-donor-release/reviews/lead1/TERMINAL-CHECK.json b/research/staged-donor-release/reviews/lead1/TERMINAL-CHECK.json new file mode 100644 index 0000000000..03a2bfd576 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/TERMINAL-CHECK.json @@ -0,0 +1,12 @@ +{ + "status": "PASS_INDEPENDENT_TERMINAL_BINDING", + "commit": "a3bdc591920a4b9003d8442d1fcca24218153661", + "stored_files": 57, + "roles": 1321920, + "physical": 323069, + "actual_prefix_bits": 1478, + "reserve": 1511, + "paid": 2048, + "kappa": "17304188997660711638039999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "scope": "Authenticated stored complete execution and exact numeric linkage; not a new heavy native/global replay." +} diff --git a/research/staged-donor-release/reviews/lead1/V2-CLOSURE.json b/research/staged-donor-release/reviews/lead1/V2-CLOSURE.json new file mode 100644 index 0000000000..90a0f9a30a --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/V2-CLOSURE.json @@ -0,0 +1,20 @@ +{ + "status": "PASS_INDEPENDENT_V2_SOURCE_CLOSURE", + "commit": "29b904054c67a40b140806698398a4af547f1d03", + "archive_sha256": "fa4222b179c2b16c197620c4000781faa5f2364384e60ef623a95e88487677c8", + "files": 734, + "v1_files": 648, + "v2_files": 652, + "modified": [ + "new/borrow/review_staged3605.py", + "new/rebuild_borrow.py", + "verify.py" + ], + "added": [ + "new/borrow/delay_applier.py", + "new/borrow/delayed/PR3605-base.json.gz", + "new/borrow/delayed/PR3605-extra.json.gz", + "new/borrow/review_delayed.py" + ], + "scope": "Exact archive closure, all predecessor source hashes reconstructible, exact declared text changes, original current word bytes retained; no terminal admission assertion." +} diff --git a/research/staged-donor-release/reviews/lead1/V2-DELAYED.json b/research/staged-donor-release/reviews/lead1/V2-DELAYED.json new file mode 100644 index 0000000000..dc349c511f --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/V2-DELAYED.json @@ -0,0 +1,59 @@ +{ + "status": "PASS_INDEPENDENT_STRUCTURAL_CERTIFICATE", + "python": "3.12.8 (main, Dec 7 2024, 10:11:37) [Clang 15.0.0 (clang-1500.3.9.4)]", + "scope": "Exact commuting proof on arbitrary full dirty states; inverse transpose follows from equality of invertible operators. Independently reconstructed cleanup and donor invoices. Does not replay native or outer admission.", + "checks": [ + { + "provider": "base", + "checks": [ + { + "start": 591, + "stop": 1045, + "exact_commutators": 453, + "crossed_warps_including_stop_cut": 30 + }, + { + "start": 641, + "stop": 1085, + "exact_commutators": 443, + "crossed_warps_including_stop_cut": 36 + } + ], + "changed_wire_bills": [ + 640, + 656 + ], + "delta": { + "1": -2, + "2": -2, + "3": 2 + } + }, + { + "provider": "extra", + "checks": [ + { + "start": 591, + "stop": 1045, + "exact_commutators": 453, + "crossed_warps_including_stop_cut": 30 + }, + { + "start": 641, + "stop": 1085, + "exact_commutators": 443, + "crossed_warps_including_stop_cut": 36 + } + ], + "changed_wire_bills": [ + 640, + 656 + ], + "delta": { + "1": -2, + "2": -2, + "3": 2 + } + } + ] +} diff --git a/research/staged-donor-release/reviews/lead1/V2-OWNER-TRANSFER.json b/research/staged-donor-release/reviews/lead1/V2-OWNER-TRANSFER.json new file mode 100644 index 0000000000..adb2044ace --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/V2-OWNER-TRANSFER.json @@ -0,0 +1,25 @@ +{ + "status": "PASS_EXACT_OWNER_WIDTH_AND_BILL_TRANSFER_WITH_EXPLICIT_JOURNAL_REUSE", + "roles": 1321920, + "physical": 323069, + "replicas": 360, + "calls": 3240, + "profile": { + "1": 7980120, + "2": 2345760, + "3": 755730, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "idle": { + "1": 84240, + "3": 23490, + "5": 5130, + "48": 137790 + }, + "old_owner_receipt_sha256": "a3ca166e604b7227f2c50a47709ecb79b7899fdace8d8d1a618648593f8c2c3b", + "new_native_receipt_sha256": "d3d796a8be3c0e13f35615938bd4d933739f394c58fe9c6c5b8337baa9ddb8ba", + "scope": "Same literal fill/order/dispatch and identical actual per-helper entrance/terminal subspaces preserve whole-call windows, family exclusion, offset/capacity and prefix obligations. New local native bill recomputed; no fresh independent million-row journal replay claimed. Original full global owner audit is separately rerun in the complete release." +} diff --git a/research/staged-donor-release/reviews/lead1/check.py b/research/staged-donor-release/reviews/lead1/check.py new file mode 100644 index 0000000000..d0580e8981 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/check.py @@ -0,0 +1,88 @@ +"""Independent structural certificate. No candidate builder or invoice imports.""" +from pathlib import Path +from fractions import Fraction as F +from collections import Counter +import gzip,json,hashlib,sys +P=Path(__file__).resolve().parents[2] +sha=lambda b:hashlib.sha256(b).hexdigest() +read=lambda p:json.loads(gzip.decompress(p.read_bytes())) +def span(b): + s={0} + for x in b:s|={x^y for y in tuple(s)} + return s +def events(w): + out=[] + for i in range(len(w['B'])+1): + out.extend(('warp',j,r) for j,r in enumerate(w['warps']) if r[0]==i) + if i0 for v in row['margins'].values()) +assert len(outer['rejecting_controls']['struct_boundary_radix_union'])==17 +assert Q(outer['native_moment'][1]['rational'])<1 +assert K>Q(read(P/'sources/T360-PRICE.json')['root_interval'][1]) +with tarfile.open(P/'REPLAY-INPUTS.tar.gz') as tf: + source=json.load(tf.extractfile('source/MANIFEST.json')) + assert hashlib.sha256(tf.extractfile('source/MANIFEST.json').read()).hexdigest()==r['source_manifest_sha256'] + for tag in ('base','extra'): + key=f'new/borrow/words/BORROW-WORD-43{tag}.json.gz';assert source[key]==sha(P/'lead1-words'/f'DELAYED-{tag}.json.gz') +print(json.dumps(dict(status='PASS_INDEPENDENT_TERMINAL_BINDING',commit='a3bdc591920a4b9003d8442d1fcca24218153661',stored_files=len(pins),roles=ind['roles'],physical=ind['physical'],actual_prefix_bits=1478,reserve=1511,paid=2048,kappa=str(K),scope='Authenticated stored complete execution and exact numeric linkage; not a new heavy native/global replay.'),indent=2)) diff --git a/research/staged-donor-release/reviews/lead1/check_v2_closure.py b/research/staged-donor-release/reviews/lead1/check_v2_closure.py new file mode 100644 index 0000000000..c3affb7e81 --- /dev/null +++ b/research/staged-donor-release/reviews/lead1/check_v2_closure.py @@ -0,0 +1,31 @@ +"""Independent exact archive and v1/v2 delta closure; no production extractor imports.""" +from pathlib import Path +import hashlib,json,tarfile,gzip +P=Path(__file__).resolve().parents[2] +sha=lambda b:hashlib.sha256(b).hexdigest() +j=lambda b:json.loads(b) +pins=j((P/'REPLAY-INPUTS.json').read_bytes());raw=(P/'REPLAY-INPUTS.tar.gz').read_bytes();assert sha(raw)==pins['archive_sha256'] +with tarfile.open(P/'REPLAY-INPUTS.tar.gz') as tf: + members=tf.getmembers();assert all(m.isfile() for m in members);assert len(members)==len({m.name for m in members}) + data={m.name:tf.extractfile(m).read() for m in members} +assert {k:sha(v) for k,v in data.items()}==pins['files'] +d=j(data['V2-DERIVATION.json']);a=j(data['_provenance/v1/source/MANIFEST.json']);b=j(data['source/MANIFEST.json']) +assert sha(data['_provenance/v1/source/MANIFEST.json'])==d['old_manifest'];assert sha(data['source/MANIFEST.json'])==d['new_manifest'] +assert len(a)==648 and len(b)==652 and not set(a)-set(b) +assert sorted(set(b)-set(a))==sorted(d['added_files']) +assert sorted(k for k in a if a[k]!=b[k])==sorted(d['modified_files']) +for k,h in b.items():assert sha(data['source/'+k])==h +for k,h in a.items():assert sha(data[('_provenance/v1/source/' if k in d['modified_files'] else 'source/')+k])==h +for patch in d['patches']: + k=patch['path'];old=data['_provenance/v1/source/'+k];new=data['source/'+k];before,after=map(str.encode,patch['replacement']) + assert sha(old)==patch['before'] and sha(new)==patch['after'] and old.count(before)==1 and old.replace(before,after)==new +old=data['_provenance/v1/admit.py'];new=data['admit.py'];assert sha(old)==d['old_driver_sha256'] and sha(new)==d['new_driver_sha256'] +assert old.replace(d['old_manifest'].encode(),d['new_manifest'].encode()).replace(b'source_file_count=648',b'source_file_count=652')==new +for tag in ('base','extra'): + assert data[f'source/new/borrow/delayed/PR3605-{tag}.json.gz']==(P/'sources'/f'STAGED644-660-{tag}.json.gz').read_bytes() + assert data[f'source/new/borrow/words/BORROW-WORD-43{tag}.json.gz']==(P/'lead1-words'/f'DELAYED-{tag}.json.gz').read_bytes() +# New copied checker must differ from independently reviewed checker only in paths/pin checks. +old=(P/'reviews/lead1/check.py').read_text();new=data['source/new/borrow/review_delayed.py'].decode() +# Every mathematical function retained byte-for-byte. +assert old[old.index('def span'):old.index('rows=[]')]==new[new.index('def span'):new.index('rows=[]')] +print(json.dumps(dict(status='PASS_INDEPENDENT_V2_SOURCE_CLOSURE',commit='29b904054c67a40b140806698398a4af547f1d03',archive_sha256=sha(raw),files=len(data),v1_files=len(a),v2_files=len(b),modified=d['modified_files'],added=d['added_files'],scope='Exact archive closure, all predecessor source hashes reconstructible, exact declared text changes, original current word bytes retained; no terminal admission assertion.'),indent=2)) diff --git a/research/staged-donor-release/runtime/sitecustomize.py b/research/staged-donor-release/runtime/sitecustomize.py new file mode 100644 index 0000000000..c19b11cd34 --- /dev/null +++ b/research/staged-donor-release/runtime/sitecustomize.py @@ -0,0 +1,13 @@ +"""Process-scoped APFS clone copies; identical byte semantics, less disk. +Only regular-file shutil copies are optimized; fallback is the stdlib copy. +No research checks or subprocess arguments are modified. +""" +import ctypes,errno,os,shutil,stat +_original=shutil.copyfile +_lib=ctypes.CDLL('/usr/lib/libSystem.B.dylib',use_errno=True) +_clone=_lib.clonefile;_clone.argtypes=[ctypes.c_char_p,ctypes.c_char_p,ctypes.c_int];_clone.restype=ctypes.c_int +def copyfile(src,dst,*,follow_symlinks=True): + if follow_symlinks and os.path.isfile(src) and not os.path.lexists(dst): + if _clone(os.fsencode(src),os.fsencode(dst),0)==0:return dst + return _original(src,dst,follow_symlinks=follow_symlinks) +shutil.copyfile=copyfile diff --git a/research/staged-donor-release/sources/PR3633-ceiling-CEILING.json b/research/staged-donor-release/sources/PR3633-ceiling-CEILING.json new file mode 100644 index 0000000000..8bbec230dd --- /dev/null +++ b/research/staged-donor-release/sources/PR3633-ceiling-CEILING.json @@ -0,0 +1,272 @@ +{ + "exponent": "1994665302554255138531/1152921504606846976000000", + "basis": [ + { + "id": 1, + "capacity": 8, + "counts": [ + 0, + 0, + 0, + 0, + 1, + 0 + ], + "idle": 0, + "amount_per_replica": "672" + }, + { + "id": 12, + "capacity": 16, + "counts": [ + 0, + 0, + 0, + 1, + 0, + 1 + ], + "idle": 0, + "amount_per_replica": "448" + }, + { + "id": 48, + "capacity": 32, + "counts": [ + 0, + 0, + 0, + 0, + 0, + 3 + ], + "idle": 5, + "amount_per_replica": "57/4" + }, + { + "id": 62, + "capacity": 32, + "counts": [ + 0, + 0, + 0, + 1, + 2, + 1 + ], + "idle": 0, + "amount_per_replica": "39/2" + }, + { + "id": 66, + "capacity": 32, + "counts": [ + 0, + 0, + 0, + 2, + 0, + 2 + ], + "idle": 0, + "amount_per_replica": "1/4" + }, + { + "id": 79, + "capacity": 32, + "counts": [ + 0, + 0, + 1, + 0, + 1, + 2 + ], + "idle": 0, + "amount_per_replica": "162" + }, + { + "id": 115, + "capacity": 32, + "counts": [ + 0, + 1, + 0, + 0, + 0, + 3 + ], + "idle": 0, + "amount_per_replica": "18" + }, + { + "id": 206, + "capacity": 32, + "counts": [ + 1, + 0, + 0, + 0, + 0, + 3 + ], + "idle": 1, + "amount_per_replica": "234" + }, + { + "id": 444, + "capacity": 48, + "counts": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "idle": 48, + "amount_per_replica": "1531/4" + }, + { + "id": 449, + "capacity": 48, + "counts": [ + 0, + 0, + 0, + 0, + 0, + 5 + ], + "idle": 3, + "amount_per_replica": "261/4" + } + ], + "dual_by_constraint": [ + { + "5": "1/4", + "48": "3/20", + "3": "-3/20" + }, + { + "5": "1/2", + "48": "3/10", + "3": "-3/10" + }, + { + "5": "1", + "48": "3/5", + "3": "-3/5" + }, + { + "48": "1" + }, + { + "5": "-1", + "1": "1" + }, + { + "5": "-1" + }, + { + "5": "-3/4", + "48": "-1/20", + "3": "1/20" + }, + { + "5": "-1/2", + "48": "-1/10", + "3": "1/10" + }, + { + "5": "-1/4", + "48": "-3/20", + "3": "3/20" + }, + { + "48": "-1/5", + "3": "1/5" + } + ], + "rhs_per_replica": [ + "672", + "448", + "448", + "448", + "234", + "18", + "162", + "468", + "873", + "1917" + ], + "full_profile_per_replica": { + "1": "22185", + "2": "6534", + "3": "8325/4", + "4": "918", + "5": "777/4", + "8": "72", + "48": "1531/4" + }, + "schema": "fixed-supplier-packing-ceiling-v1", + "widths": [ + 4, + 5, + 6, + 7, + 8, + 9 + ], + "capacities": [ + 8, + 16, + 32, + 48 + ], + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 52, + "8": 97, + "9": 213 + }, + "local_profile": { + "1": 2439, + "2": 726, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "root_interval": [ + "199466530255425513853/115292150460684697600000", + "1994665302554255138531/1152921504606846976000000" + ], + "scaled_root_profile": { + "1": 88740, + "2": 26136, + "3": 8325, + "4": 3672, + "5": 777, + "8": 288, + "48": 1531, + "73": -3584 + }, + "scope": "Fixed changed PR3605 supplier, four capacity classes, nine calls per replica; chronology relaxed for dual. Literal realization/native/outer admission and other suppliers/geometries are separate.", + "candidate_scientific_fields": [ + "baseT", + "S", + "order", + "dispatch", + "groups", + "widths", + "inventory", + "local_profile", + "x", + "z", + "profile" + ], + "candidate_scientific_sha256": "a40308d5e7dccbd1ad219a8497c96747423ba6a395ee4f77b68c89087acdfca1" +} diff --git a/research/staged-donor-release/sources/PR3633-ceiling-PROOF.md b/research/staged-donor-release/sources/PR3633-ceiling-PROOF.md new file mode 100644 index 0000000000..d214b71b43 --- /dev/null +++ b/research/staged-donor-release/sources/PR3633-ceiling-PROOF.md @@ -0,0 +1,28 @@ +# Packing ceiling for the changed 408-helper supplier + +This certificate concerns one fixed supplier and capacity model. The widths are (4,5,6,7,8,9), their per-call inventory is (26,2,18,52,97,213), and the supplier's paid local profile is 2439H1+726H2+224H3+102H4+20H5+8H8. There are nine calls per replica and respectively (672,448,448,448) bins of capacities (8,16,32,48). Here H_r(a)=r^(1−a). + +Every nonnegative integer pattern that fits one bin is enumerated: 2,551 patterns. The certificate contains a feasible rational primal basis and ten dual coefficients, each expressed as a rational linear combination of H_r. At the recorded rational upper root endpoint, the verifier proves all dual inequalities by rational log/exponential intervals. Twelve reduced costs vanish symbolically; the other 2,539 are strictly positive. The primal uses tight patterns and satisfies all ten equalities exactly, establishing the fractional minimum at that exponent. + +The supplied T488 aggregate is bound by its canonical scientific-field SHA-256 (baseT, S, order, dispatch, groups, widths, inventory, local_profile, x, z, profile). The verifier independently checks its bin counts, width totals, idle cost, full paid profile, and tightness of every used pattern. Its per-replica profile equals the primal optimum: + +22185H1 + 6534H2 + (8325/4)H3 + 918H4 + (777/4)H5 + 72H8 + (1531/4)H48. + +The certificate also bounds the zero of this profile minus 896H73, approximately 0.0017300963635286236. Both endpoint signs are independently recomputed. After division by H73, every positive term is a positive multiple of (r/73)^(1−a), which is strictly increasing in a because r<73; therefore the bracket contains its unique zero. The dual certificate is explicitly evaluated at the upper endpoint, not asserted uniformly for arbitrary exponents. + +This removes chronology, source windows, family constraints and integrality from the packing lower bound. Attainment by the aggregate is useful mathematical evidence, but literal-owner correctness and full native/outer admission are separate checks. No optimality claim concerns other suppliers, capacities, geometries, or recursive interfaces. + +## Replay + +With Python's standard library only: + + python -I -B verify_ceiling.py CANDIDATE.json CEILING.json --out RESULT.json + python -I -B test_ceiling.py CANDIDATE.json + +The candidate path is explicit. There are no imports from a checkout or private tooling directory, no optimizer dependencies, and no network/Git operations. JSON whitespace and non-scientific metadata do not affect the candidate binding; the complete scientific-field projection is fixed by the verifier. The private optimization pipeline is intentionally absent. + +## Attribution + +The width change is the staged-release construction in PR3605. The capacity model and finite-pattern primal/dual approach descend from the retained coupled-carrier-cap740 certificate. T488 combines the retained T37 chronology with the T8 and T16 chronologies and supplies a newly reconstructed aggregate. This component certifies the resulting fixed-model packing equality; it does not claim ownership of the supplier or predecessor chronologies. + +At the certified upper endpoint, the dual lower bound makes every admissible profile’s normalized cost at least one. Since all positive occupied ranks are strictly below73, each such normalized cost increases with κ; no larger κ can satisfy the required cost inequality in this fixed model. This conclusion uses the dual only at that endpoint, not a uniform dual certificate across κ. diff --git a/research/staged-donor-release/sources/PROOF.md b/research/staged-donor-release/sources/PROOF.md new file mode 100644 index 0000000000..020ab84ae7 --- /dev/null +++ b/research/staged-donor-release/sources/PROOF.md @@ -0,0 +1,224 @@ +# Staged incoming-helper bases on the pinned PR3133 word + +This is a finite exact local construction. It keeps helpers 644 and 660 and +changes each ordinary helper width 8 to 7. It does **not** supply the originally +requested width 7 to 6 extraction, a chronological owner allocation, or a new κ. +Those distinctions matter: the successful construction uses direct inverse +cleanup on ordinary FULL-ended helpers rather than declaring a new cold helper. + +The sole word input is PR3133 commit +`51eb9c4ee9e4722010d308aa3309e039d3940cc2`, directory +`research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-{base,extra}.json.gz`. +The frozen outputs are `STAGED644-660-{base,extra}.json.gz`. Their compressed +SHA256 values are respectively +`735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653` and +`886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f`. + +## Contract and changed premise + +Work over exact dyadic Gaussian coefficients; the free-operator audit works +over rational coefficients with independent invertible warp symbols. Every +one of the 632 remaining source, target and helper inputs is arbitrary and +independent. There are 408 helper roles and 91 explicitly zero private cleanup +buffers. The old removed-register set, source ports, targets, centre cut, +native warp matrices/charts, target compensation and operator corrections +are unchanged. Each completed local map is `y_t += x_t`, with every other +input restored and every private buffer zero, in both orientations. + +Write `L=span_F2{30}`, `P=span_F2{429,30}`, and `F=F_2^9`. Their ranks are 1,2,9. +Both affected helpers originally enter at L and end at F. They now enter at P +and still end at F. A nonzero frame is never treated as a zero value. + +The earlier 511-line common-release obstruction excluded existing entering +helpers and fixed the positive word. Here all six coordinates are existing +nonzero-entry, nonrestored helpers, and eight early target contacts are +changed. Thus that earlier obstruction does not cover this construction. +The old fixed factory endpoint/source 47/429 or 21/53 substitution arguments +also retain different input coordinates, scalar words and source contracts. +No true source input is mixed here. + +## Two exact prefix directions + +Let `e_j` denote a helper input coordinate and put + +``` +w1 = 2 e640 - 2 e496, S1 = I + w1 e644*, +w2 = - e656 - 2 e520, S2 = I + w2 e660*. +v1 = e644 + w1, v2 = e660 + w2. +``` + +All six supports are disjoint between the two changes. Within either change, +the pivot is absent from w, so `S_i^-1 = I - w_i e_h*`. Also `S1 S2=S2 S1`. +All six helpers have entryL, endF, noA contact, no initial operator correction, +and zero columns in the inherited target compensation C. Consequently +`C S1 S2=C`, and the initial correction source set is unchanged. + +The early target-column tables, with omitted entries zero, are: + +| target register | column644 | column640 | column496 | +|---|---:|---:|---:| +|135|1/2|-1/4|0| +|146|-1/2|1/4|0| +|162|1/2|-1/4|0| +|220|1/2|1/4|1/2| + +| target register | column660 | column656 | column520 | +|---|---:|---:|---:| +|141|1/2|1/2|0| +|171|1/2|-1/2|1/2| +|185|-1/2|-1/2|0| +|196|1/2|1/2|0| + +Each table kills its displayed v exactly. These are dirty-input columns, +including lender dirt; no clean-source projection was used. + +Delete old B184..187, which are the four raw 644 target writes, and old B216..219, +the four raw 660 target writes. Before old B599 emit, at P, + +``` +640 += 2*644 +496 -= 2*644 +``` + +Before old B647 emit, also at P, + +``` +656 -= 660 +520 -= 2*660 +``` + +The helpers carrying these releases retain their old values until their +respective first actual producers. The tables therefore show that deleting +the pivot target columns and then making the release implements the old +prefix times S. `check_scope.py` independently propagates the six affected arbitrary input +columns through the prefix and checks `P_new=P_old S1 S2` before old B647. +It verifies that these coordinates have no earlier A or compensation contact +and that no nonzero affected column crosses a native warp. Every other column +is unchanged by the displayed edits, giving the full prefix identity. The +separate inherited auditor checks the completed map on every arbitrary input. The input S in this +factorization is algebraic; no additional zero-frame S gate is silently charged +as free. Its physical implementation is the displayed changed word. + +The old completed target shear annihilates every helper input. Hence right +multiplication by these helper-only S matrices preserves the original external +source-to-target map. In particular, this proof does not use the invalid rule +that `C S` alone preserves a changed true-source basis. + +## Terminal and inverse cleanup + +Let M be the old non-target forward operator before FULL cleanup. The changed +forward operator is `M S1 S2`. Every old restored-helper row and column stays +the literal identity: the supports of S1,S2 are disjoint from all 91 restored +input coordinates, and the corresponding old M rows/columns are isolated. +Thus the old private-buffer namespace and its entrance-zero contract survive. + +The six changed coordinates are ordinary FULL-ended helpers. Cleanup may read +their real registers; it is regenerated as the literal inverse of the complete +changed non-target forward word, including inverse warps and the inherited +zero-buffer substitution for the 91 cold helpers. It restores every non-target input and clears every private buffer; the targets retain the specified shear. +No new precleanup row/column isolation is asserted for 644 or 660. Isolation is +checked for every old cold helper before cleanup, and for all coordinates at +the completed boundary. This is why no extra private buffer is required. + +The actual physical helper residual is the paired operator + +``` +T_F T_P^-1, +L_wrapper^-1 T_F T_P^-1 R_wrapper^-1 = C_[7] tensor I_[2]. +``` + +`check_residual.py` verifies all 512 Gaussian columns including global phase, +using independently decoded monomial recipes. It rejects the old rank 8 wrapper, +a changed global phase, and omission of the entrance transform. The same-order +dual identity is its exact inverse transpose. + +## Complete local invoice and frame legality + +The common frame P is contained in both relevant first-body frames. For 644: +donor 496 first reaches `span(385,44,30)` of rank 3, and 640/644 first reach +`span(423,65,20,10)` of rank 4. For 660 the corresponding frames are +`span(429,70,30)` and `span(427,96,24,6)`. These contain P exactly. No frame is +inferred merely from dimension. Every full changed monotone chain is separately +checked by native transport and independent local replay. + +Per pivot, the changed climb histograms are + +``` +pivot: H2 - H3 +first donor: H1 + H2 - H3 +second donor:2 H1 - H2 +total: 3 H1 + H2 - 2 H3. +``` + +Their disjoint combination gives + +``` +old L = {1:2433,2:724,3:228,4:102,5:20,8:8} +new L = {1:2439,2:726,3:224,4:102,5:20,8:8} +delta = 6 H1 + 2 H2 - 4 H3 + +old I = {4:26,5:2,6:18,7:50,8:99,9:213} +new I = {4:26,5:2,6:18,7:52,8:97,9:213}. +``` + +The local rank mass falls by 2, exactly matching the owned-width decrease. +Idle owner remainders are **not** included in this local invoice. Stock, +91 private buffers and 408 roles are fixed. + +The only other solved-frame edit is restore 210, the sign change of source 96: +its frame moves from the old rank 8 hyperplane to FULL. Source 96 already reaches +FULL at restore 211. This moves the same rank 1 jump across a scalar sign change +and changes no paid histogram. No A or surviving B gate frame changes. The frozen +declared records include this edit rather than omitting it from provenance. + +In the inherited sorted live-helper order,644 is role 389/native register 613; +660 is role 397/native register 621, for both gauge 44 and extra providers. These +are existing whole roles with reduced width, not deleted or fractional roles. + +## Exact verification and finite precision scope + +`verify.py` freshly executes both complete six-stage native runs: transport, residual +adapters, emitter, independent local replay, exact local phases, independent +warp recipe checks. All stages use the actual new words; no predecessor native +receipt substitutes for them. Each orientation has 632 arbitrary columns, +91 cleared buffers, 22,768 events and 17,449 scalar macros. Real-component +primitive bounds are 158,144 forward and 158,192 backward. The phase stage checks +all used local edges including global phase, and every warp recipe against +its exact 512-column Gaussian product. + +The conservative fresh logical prefix reserves are 89 bits forward and 95 bits +backward, below the inherited local 128-bit reserve; the local auditor charges +192 payload bits. This finite logical prefix check does not establish a rounded recursive-child +precision contract. Global rounded precision and stopping exponents remain +separate caller obligations. + +Negative controls omit a real release shear and regenerate cleanup; they still +fail the original targets (135/162 for 644,141/196 for 660). Flipping either real release coefficient also fails the target map. These +controls check the actual endpoint, independently of profile metadata. Declared reconstruction rejects +wrong scalar preimages and changed release coefficients. Wrapper controls above +separately exercise phase, entrance and paid-width binding. + +`staged_pair.py` is a self-contained standard-library deterministic applier with +no frame optimizer. `STAGED-PAIR-RECORD-{base,extra}.json.gz` declares every edit +and solved frame preimage and regenerates inverse cleanup. Rebuilds reproduce +the complete decoded frozen word; `verify.py` checks semantic equality and +authenticates the immutable compressed inputs. Generated gzip headers and +streams are not used as a mathematical equality test. The earlier +PR3133 declared-edit review must still run on its own predecessorFINAL words; +these new records are a subsequent stage, not a replacement for that review. + +## Remaining obligations and attribution + +The construction alone does not provide changed-inventory fractional packing, +a chronological integral owner fill, all unused owner remainders, native owner +hosting, a complete block-norm context, rounded all-size recursive precision, +stopping exponent, finite-tape realization, or outer interval inequality. Those +must bind this exact pair of words and its new inventory. No κ follows here. + +The word lineage and native/free-operator tools retain their source attributions: +PR2857's staged compensation kernels, PR2908/2917's paired/helper and native +interfaces, PR2979's joint word/inventory construction, and PR3133's coupled +carrier folds. The new staged incoming directions and their literal local +validation are established above; historical claims do not certify this word. +This package gives finite exact computation and the written linear identities, +not a formal-kernel theorem or an unconditional multiplication bound. diff --git a/research/staged-donor-release/sources/STAGED644-660-base.json.gz b/research/staged-donor-release/sources/STAGED644-660-base.json.gz new file mode 100644 index 0000000000..dc6d321b1e Binary files /dev/null and b/research/staged-donor-release/sources/STAGED644-660-base.json.gz differ diff --git a/research/staged-donor-release/sources/STAGED644-660-extra.json.gz b/research/staged-donor-release/sources/STAGED644-660-extra.json.gz new file mode 100644 index 0000000000..78e7b2bb06 Binary files /dev/null and b/research/staged-donor-release/sources/STAGED644-660-extra.json.gz differ diff --git a/research/staged-donor-release/sources/T360-PRICE.json b/research/staged-donor-release/sources/T360-PRICE.json new file mode 100644 index 0000000000..27e00b625f --- /dev/null +++ b/research/staged-donor-release/sources/T360-PRICE.json @@ -0,0 +1,33 @@ +{ + "root_interval": [ + "0.00173009636352862353423", + "0.001730096363528623534231" + ], + "endpoint_expression": "0.00173009636352862353423 - 10^-46 - 10^-70", + "replicas": 360, + "profile": { + "1": 7986600, + "2": 2352240, + "3": 749250, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "comparator_pr": 3624, + "comparator_head": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "comparator_replicas": 450, + "comparator_profile": { + "1": 9983580, + "2": 2940300, + "3": 936579, + "4": 413100, + "5": 87495, + "8": 32400, + "48": 172221 + }, + "comparator_root_interval": [ + "0.001730047552093344159584", + "0.001730047552093344159585" + ] +} diff --git a/research/staged-donor-release/sources/check_scope.py b/research/staged-donor-release/sources/check_scope.py new file mode 100644 index 0000000000..cea3481a63 --- /dev/null +++ b/research/staged-donor-release/sources/check_scope.py @@ -0,0 +1,135 @@ +"""Exact source patch, scalar identity and literal frame invoice. +Adapted from a separate OpenAI Codex review by Ross Richardson. +Assertions must remain active; the public driver starts this in an unoptimized +child interpreter with an isolated bytecode-cache namespace.""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter,defaultdict +from functools import lru_cache +import gzip,hashlib,json,sys +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +SRC=ROOT/'research/rank7-coupled-586-588-carrier-fold/edits' +@lru_cache(None) +def span(xs): + a={0} + for x in xs:a|={v^x for v in tuple(a)} + return frozenset(a) +def dim(s): + d=len(s).bit_length()-1;assert len(s)==1< bit and (pivots[higher] >> bit) & 1: + pivots[higher] ^= pivots[bit] + return tuple(pivots[k] for k in sorted(pivots, reverse=True)) + + +@lru_cache(maxsize=32768) +def join(left, right): + return basis(left + right) + + +@lru_cache(maxsize=32768) +def contains(frame, vector): + for pivot in frame: + if vector.bit_length() == pivot.bit_length(): + vector ^= pivot + return vector == 0 + + +@lru_cache(maxsize=8192) +def points(frame): + result = [0] + for v in frame: + result += [x ^ v for x in result] + return tuple(result) + + +@lru_cache(maxsize=32768) +def meet(left, right): + if len(left) > len(right): + left, right = right, left + return basis(v for v in points(left) if contains(right, v)) + + +def inside(left, right): + return all(contains(right, v) for v in left) + + +def operands(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def build(word, free_warps=False): + start = [(p,) for p in word['ports']] + [ZERO] * 592 + end = [FULL] * 112 + [basis(v for v in range(1, 512) + if (v & p).bit_count() % 2 == 0) for p in word['ports']] + [FULL] * 480 + for r, frame in word['start_extra'].items(): + start[int(r)] = basis(frame) + for r, frame in word['helper_final'].items(): + end[int(r)] = basis(frame) + labels, incoming, outgoing = [], [], [] + current = [(-1, f, ('start', r)) for r, f in enumerate(start)] + def anchor(r, before, after, label): + previous, _, _ = current[r] + if previous >= 0: + outgoing[previous].append((-1, basis(before), label, r)) + current[r] = (-1, basis(after), label) + def scalar(section, position, gate): + index = len(labels) + labels.append((section, position)) + incoming.append([]) + outgoing.append([]) + for r in operands(gate): + previous, frame, label = current[r] + incoming[index].append((previous, frame, label, r)) + if previous >= 0: + outgoing[previous].append((index, ZERO, None, r)) + current[r] = (index, ZERO, None) + for i, gate in enumerate(word['A']): + if gate[0] == 'warp': + before, after = (FULL, ZERO) if free_warps else (gate[3], gate[4]) + anchor(gate[1], before, after, ('A_warp', i)) + else: + scalar('A', i, gate) + for r, frame in zip(word['centers'], word['center_frames']): + anchor(r, frame, frame, ('centre', r)) + by_position = {} + for i, record in enumerate(word['warps']): + by_position.setdefault(record[0], []).append((i, record)) + for i in range(len(word['B']) + 1): + for j, rec in by_position.get(i, []): + before, after = (FULL, ZERO) if free_warps else (rec[3], rec[4]) + anchor(rec[1], before, after, ('B_warp', j)) + if i < len(word['B']): + scalar('B', i, word['B'][i]) + for i, gate in enumerate(word['restore']): + scalar('restore', i, gate) + for r in range(704): + if r not in word['removed']: + anchor(r, end[r], end[r], ('end', r)) + return dict(labels=labels, incoming=incoming, outgoing=outgoing) + + +def bounds(graph): + lower = [] + upper = [FULL] * len(graph['labels']) + for incoming in graph['incoming']: + frame = ZERO + for previous, anchor, _, _ in incoming: + frame = join(frame, lower[previous] if previous >= 0 else anchor) + lower.append(frame) + for i in reversed(range(len(lower))): + for following, anchor, _, _ in graph['outgoing'][i]: + upper[i] = meet(upper[i], upper[following] if following >= 0 else anchor) + bad = [i for i in range(len(lower)) if not inside(lower[i], upper[i])] + return lower, upper, bad + + +def witness(graph, lower, upper, bad): + """One explicit fixed-anchor -> scalar chain -> fixed-anchor contradiction.""" + pivot = bad[-1] + required = upper[pivot] + chain = [pivot] + current = pivot + while True: + edge = next(e for e in graph['incoming'][current] + if not inside(lower[e[0]] if e[0] >= 0 else e[1], required)) + previous, frame, label, _ = edge + if previous < 0: + vector = next(v for v in frame if not contains(required, v)) + origin = dict(label=label, frame=frame) + break + chain.append(previous) + current = previous + chain.reverse() + current = pivot + while True: + edge = next(e for e in graph['outgoing'][current] + if not contains(upper[e[0]] if e[0] >= 0 else e[1], vector)) + following, frame, label, _ = edge + if following < 0: + destination = dict(label=label, frame=frame) + break + chain.append(following) + current = following + result = dict(vector=vector, origin=origin, destination=destination, + scalar_path=[graph['labels'][i] for i in chain]) + validate_witness(graph, result) + return result + + +def validate_witness(graph, result): + """Check the certificate from literal edges alone; no lower/upper computation.""" + vector, origin, destination = result['vector'], result['origin'], result['destination'] + lookup = {label: index for index, label in enumerate(graph['labels'])} + chain = [lookup[tuple(label)] for label in result['scalar_path']] + if not chain: + raise ValueError('empty scalar path') + first_edges = graph['incoming'][chain[0]] + if not any(e[0] < 0 and e[2] == origin['label'] and contains(e[1], vector) + for e in first_edges): + raise ValueError('unbound origin') + for first, second in zip(chain, chain[1:]): + if not any(e[0] == second for e in graph['outgoing'][first]): + raise ValueError('broken scalar frame path') + if not any(e[0] < 0 and e[2] == destination['label'] and not contains(e[1], vector) + for e in graph['outgoing'][chain[-1]]): + raise ValueError('unbound forbidden destination') + return True diff --git a/research/staged-donor-release/sources/owner-transfer/CANONICAL-base.json.gz b/research/staged-donor-release/sources/owner-transfer/CANONICAL-base.json.gz new file mode 100644 index 0000000000..98176a2976 Binary files /dev/null and b/research/staged-donor-release/sources/owner-transfer/CANONICAL-base.json.gz differ diff --git a/research/staged-donor-release/sources/owner-transfer/CANONICAL-extra.json.gz b/research/staged-donor-release/sources/owner-transfer/CANONICAL-extra.json.gz new file mode 100644 index 0000000000..cb2d048caf Binary files /dev/null and b/research/staged-donor-release/sources/owner-transfer/CANONICAL-extra.json.gz differ diff --git a/research/staged-donor-release/sources/owner-transfer/EVIDENCE-PINS.json b/research/staged-donor-release/sources/owner-transfer/EVIDENCE-PINS.json new file mode 100644 index 0000000000..386ac7a106 --- /dev/null +++ b/research/staged-donor-release/sources/owner-transfer/EVIDENCE-PINS.json @@ -0,0 +1,23 @@ +{ + "scope": "Authenticated stored completed execution; not a fresh replay", + "files": { + "FILL-BINDING.json": "53d6ad1803352e697ff0fb368ce050ffdcb490274c4b5ab91466e4cb6b696106", + "FINAL-RELEASE.txt": "2ad8d7bac4060c7633952df5947f0ff479f4f4210b7af1f29a3c548a34c0a0d1", + "FIRST-ENVIRONMENT-CHILD.txt": "b9a5cfcd2aaf030c94fadb2b50137ef2ac8554ec3753d3c11e7dd4e4ca167370", + "FIRST-ENVIRONMENT-FAILURE.txt": "d9074414e05cf737cf357d17263731b9e170e195d51105348786b06773af5139", + "FULL-ADMISSION.txt": "2a53dea33dc76edd44fbaa28e9d904433fa86aae31dfad7486aca6b157e8e588", + "FULL-ENTRY-RESULT.json": "fb87e89ef9bd5d45696b16189f662f3849502d591a2f0aa8ee5c1ea59bc1ef90", + "INDEPENDENT-OWNERS.json": "a3ca166e604b7227f2c50a47709ecb79b7899fdace8d8d1a618648593f8c2c3b", + "LITERAL-REPLAY.json": "2e0663edb81e206beeac476e3e41816417a059fd5b4ff05aeae6a6d642b777e3", + "NATIVE-COMMANDS-base.json": "ad0d73a2b6d2c57bb9069af09804fc521bcac95a78f35440612dc6ef87753289", + "NATIVE-COMMANDS-extra.json": "10904894e72476c90fa265976778c3c8866d27745989c3c77167e338faaf91e3", + "NATIVE-ENVIRONMENT.json": "669f77d5bcd2ad1793c58b6e94e85fa875cd9cbd54d23dc5be085ddf5fed5e04", + "NATIVE-RECEIPT.json": "063ca4d8c1486786088a2fbf40101bd9ed0d32e393139edbfdaa290255a48a00", + "NATIVE-RESULT-base.json": "e4ff061307943f01109dbc6334af8f72abb43e2b11e82f6543883bdcfdb25310", + "NATIVE-RESULT-extra.json": "41d1613ff10b4d677a8477840f8a9e325dfd17327108ecf5a2d628596bb2cdff", + "NATIVE-SUMMARY.txt": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "PREFIX-AND-INVOICE.json": "02ea41b3b3ea1d76ae2084f3f8822202b9e0f8008afcef56b2ae47d66147ef2f", + "RELEASE-RECEIPT.json": "5c029c2bc559f1fa3b48abbe6bee8f131ab397381a95c98e436532fdfe83e597", + "RESULT.json": "4567e1e998997aca156ac58dcff81aa5beb08e56cd7546e9e560788a9935f07d" + } +} diff --git a/research/staged-donor-release/sources/owner-transfer/FILL-BINDING.json b/research/staged-donor-release/sources/owner-transfer/FILL-BINDING.json new file mode 100644 index 0000000000..9a317dcdc6 --- /dev/null +++ b/research/staged-donor-release/sources/owner-transfer/FILL-BINDING.json @@ -0,0 +1,7 @@ +{ + "literal_sha256": "8ea003fd8119c57140cc710e106cce56b00a245bbaf10813813d34744ecf90b1", + "admission_sha256": "c55e03fadd1264c70bfa28711d79eaa28b8efd46e3e2306f9719e629254fcd0e", + "literal_payload_sha256": "9c7288f6b65ea8b4509b658c7df881963410c144e112b6c8accf03283ddf2828", + "semantic_equality": true, + "rows": 1321920 +} diff --git a/research/staged-donor-release/sources/owner-transfer/INDEPENDENT-OWNERS.json b/research/staged-donor-release/sources/owner-transfer/INDEPENDENT-OWNERS.json new file mode 100644 index 0000000000..e87f12a19b --- /dev/null +++ b/research/staged-donor-release/sources/owner-transfer/INDEPENDENT-OWNERS.json @@ -0,0 +1,41 @@ +{ + "calls": 3240, + "controls": [ + "duplicate helper", + "strict lower endpoint used as available", + "same-call family reused", + "unpaid chronological hole", + "one unpaid rank1 child" + ], + "idle": { + "1": 84240, + "3": 23490, + "5": 5130, + "48": 137790 + }, + "input_sha256": { + "/Users/temp/.codex/worktrees/three-kappa-leads/integer-mult-bounds/research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "/Users/temp/.codex/worktrees/three-kappa-leads/integer-mult-bounds/research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "/private/tmp/three-kappa-materialized/changed/native-py312/native-cache/735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/CANONICAL-WORD.json.gz": "b87f174cd72d194f23c075fd82b2fe42f5e9606e8500e4dfa23c31e8655c8de5", + "/private/tmp/three-kappa-materialized/changed/native-py312/native-cache/886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/CANONICAL-WORD.json.gz": "8276f3d7f6f85bf3d678832f63baabb38550d11ed8f3841aa47020121e8e4e82", + "/private/tmp/three-kappa-t360-owners/DISPATCH.json": "8064e69e9be904bd81219fdde3b895adbad8d5c43c3a97de46a3aebbdb4424da", + "/private/tmp/three-kappa-t360-owners/FILL.json.gz": "8ea003fd8119c57140cc710e106cce56b00a245bbaf10813813d34744ecf90b1", + "/private/tmp/three-kappa-t360-owners/ORDER.json": "e14d3c8b183f82ea1f8b1cbdf70d2fb07e450340ebb51815756b1248aa0609d6", + "/private/tmp/three-kappa-t360-owners/PROFILE.json": "c31b921f5767c5f1f7d9d75f50c55eab1dc6f8e3143453058b0b13b115582ec4" + }, + "physical": 323069, + "profile": { + "1": 7986600, + "2": 2352240, + "3": 749250, + "4": 330480, + "5": 69930, + "8": 25920, + "48": 137790 + }, + "replicas": 360, + "roles": 1321920, + "scope": "Independent finite vectorized audit; no producer, solver, retained owner checker or reconstructor imports. Actual native frames are authenticated input data; their separate full operator proofs are required.", + "script_sha256": "89c27f61ae3e6d2bdd4c469ac5b99d4f955a443c5e04c74e568c12093510efbe", + "status": "PASS_INDEPENDENT_LITERAL_OWNER_WINDOWS_FAMILIES_PREFIXES_AND_INVOICE" +} diff --git a/research/staged-donor-release/sources/owner-transfer/NATIVE-RECEIPT.json b/research/staged-donor-release/sources/owner-transfer/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..3c1ea3d2b9 --- /dev/null +++ b/research/staged-donor-release/sources/owner-transfer/NATIVE-RECEIPT.json @@ -0,0 +1,113 @@ +{ + "cache_files": { + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/CACHE.json": "a1f571048cfef36a461a04b6d8da7fc4818370683ab165183f611d8ff7868a19", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/STEPS.json": "4b4d02da756db7367c282e7404962bb46828c0a7427fd7372fc238e3f837002b", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/CANONICAL-WORD.json.gz": "b87f174cd72d194f23c075fd82b2fe42f5e9606e8500e4dfa23c31e8655c8de5", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/CLIFFORD-RECIPES.json": "2bfff13b291f8112d6e0dd1129db57849da11aba9fc01de5f070fb80bd77857b", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/CLIFFORD-REVIEW.json": "3a31ed9e35e3d850ecee78d5a5138b26891c665956db62cfe1cde19ce4d77dbd", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/FULL-WORD.json.gz": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/INDEPENDENT-LOCAL-REPLAY.json": "57c4bb8b11b83e8339b157c662cc8b87d97919dc7edb6ec5516065dd221c5e3f", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/LOCAL-CHECKS.json": "1cd75f8209677e59bb26be8d7d0920109628a5da1ff80d4f07b03356711a2237", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/LOCAL-PROGRAMS.json.gz": "86726cc4014d65848cbda3ce093cea96f9411d17e6368a77eb3523bdddb6ff7d", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/RESIDUAL-ADAPTERS.json": "a19e744f741bf917a72d63aab09cf7e10f5566091458568747b97f7bf0ea945a", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/SCALAR-FRAME-AUDIT.json": "d41ff258621fc9b06107b0e38233677ef82e0ecd5a97eaa7491158224a478038", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/WARP-RECIPE-CHECKS.json": "60ca36d81336a622686904f89d66d6aee8522f49a627fa041d527503f58eb1f7", + "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653/local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "3ed6859152f2594352bea363ce8d297f93dc138a5748b2a55523e89d2eef3776", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "02a8f2021aa8406277656a086d875a2d50cea569e5179c27d2bcaed92d9826ff", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "45647f1d24501ae4feea3a0247299c18437bf66b67028a24feb442318de75767", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "b450451f2b4bb99eb58f2cc687c3d498861c51696ada2689982ba71563eda19e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "14b7804c767c6734b6caeff749002be8213e8eab7ceb87868573e44f57a107b0", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "0a6146b4b02d0d4e7ce82ffc10c04992949e362c6437a7d4aba61b7c1c80c5ca", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/CACHE.json": "29a5756876a420281abecec1bec25d5030fc606c0d896a78fed8c6a0fe3a9d4c", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/STEPS.json": "a9f17624eebcac2d5bfaee535837ef288964b310db5f07f64dfce7b3cc910e1e", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/CANONICAL-WORD.json.gz": "8276f3d7f6f85bf3d678832f63baabb38550d11ed8f3841aa47020121e8e4e82", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/CLIFFORD-RECIPES.json": "c406b59021d2560f5405da13fd58e31620445ec3c89c221cc428a98260ccb47c", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/CLIFFORD-REVIEW.json": "fd6515b753fc27ee1d78f26b65d0b9107dc6bd2243cd491b17cc81d7a05f5df7", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/FULL-WORD.json.gz": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/INDEPENDENT-LOCAL-REPLAY.json": "cc0d5b7d8c57a4a08e0dcc23eee67f913e47a7d05f8a816e0af7da141747b3f6", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/LOCAL-CHECKS.json": "1cd75f8209677e59bb26be8d7d0920109628a5da1ff80d4f07b03356711a2237", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/LOCAL-PROGRAMS.json.gz": "86726cc4014d65848cbda3ce093cea96f9411d17e6368a77eb3523bdddb6ff7d", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/RESIDUAL-ADAPTERS.json": "c4ddd4db13db5ed6b3672f8ddd0dc3a2bfff50068779b51489c6f002972f6163", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/SCALAR-FRAME-AUDIT.json": "faa10cbdafa561c412573c0562c9e747a7c67c9868c89e91f605a2bac57f2683", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/WARP-RECIPE-CHECKS.json": "e14580302b11eaed5e0d96a421935eef3b34fb10d9f8d9fc26d5364a30b2370b", + "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f/local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "bc1bc13637846b3807119ae55dd006c8076815f355c93e0a1f57c1dce3ebeb3e", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "845e82a755ac46ea2f62b79700f7af6037616408a8359e615c24d351713c8c12", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "b0d0263a87e95da1dc03e552c878ba4da4494184d1560ecc66e4dd93d7129a0b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "2ab0c916ce58b97c3bca6b2d0369168f3626f06c7cf566dec0ead919ba7d7940", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "ae00b2906950db818416e47984cb08ecbf55ba836d68e5fce7bfb94926a91bc5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "1eac718473827728f905380793bc91b8f1c89521fcf1fb978bd9091170d3e8ee", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "4be1b04a3504e228e3fc95ef8cb4805272dacd6bd0616b8b4aef649c80a901ae", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "9bb4169a54cf20008b1bffcb08e2bacd59b4aeab4faa7bbae6c462c5083cb07a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "da5230122cb781ac3fa5c98b08356c0af2050cf70e13f2f52ebec19ffb39aea1", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "fresh_current_provider_count": 2, + "fresh_retained_native_count": 0, + "fresh_retained_parent": false, + "manifest_sha256": "318ede57c79d10323fb1918f7be4d451d1fcdac01c6456fe9851d51d05d59453", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "4b4d02da756db7367c282e7404962bb46828c0a7427fd7372fc238e3f837002b", + "local/CANONICAL-WORD.json.gz": "b87f174cd72d194f23c075fd82b2fe42f5e9606e8500e4dfa23c31e8655c8de5", + "local/CLIFFORD-RECIPES.json": "2bfff13b291f8112d6e0dd1129db57849da11aba9fc01de5f070fb80bd77857b", + "local/CLIFFORD-REVIEW.json": "3a31ed9e35e3d850ecee78d5a5138b26891c665956db62cfe1cde19ce4d77dbd", + "local/FULL-WORD.json.gz": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "local/INDEPENDENT-LOCAL-REPLAY.json": "57c4bb8b11b83e8339b157c662cc8b87d97919dc7edb6ec5516065dd221c5e3f", + "local/LOCAL-CHECKS.json": "1cd75f8209677e59bb26be8d7d0920109628a5da1ff80d4f07b03356711a2237", + "local/LOCAL-PROGRAMS.json.gz": "86726cc4014d65848cbda3ce093cea96f9411d17e6368a77eb3523bdddb6ff7d", + "local/RESIDUAL-ADAPTERS.json": "a19e744f741bf917a72d63aab09cf7e10f5566091458568747b97f7bf0ea945a", + "local/SCALAR-FRAME-AUDIT.json": "d41ff258621fc9b06107b0e38233677ef82e0ecd5a97eaa7491158224a478038", + "local/WARP-RECIPE-CHECKS.json": "60ca36d81336a622686904f89d66d6aee8522f49a627fa041d527503f58eb1f7", + "local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485" + }, + "word_sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "a9f17624eebcac2d5bfaee535837ef288964b310db5f07f64dfce7b3cc910e1e", + "local/CANONICAL-WORD.json.gz": "8276f3d7f6f85bf3d678832f63baabb38550d11ed8f3841aa47020121e8e4e82", + "local/CLIFFORD-RECIPES.json": "c406b59021d2560f5405da13fd58e31620445ec3c89c221cc428a98260ccb47c", + "local/CLIFFORD-REVIEW.json": "fd6515b753fc27ee1d78f26b65d0b9107dc6bd2243cd491b17cc81d7a05f5df7", + "local/FULL-WORD.json.gz": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "local/INDEPENDENT-LOCAL-REPLAY.json": "cc0d5b7d8c57a4a08e0dcc23eee67f913e47a7d05f8a816e0af7da141747b3f6", + "local/LOCAL-CHECKS.json": "1cd75f8209677e59bb26be8d7d0920109628a5da1ff80d4f07b03356711a2237", + "local/LOCAL-PROGRAMS.json.gz": "86726cc4014d65848cbda3ce093cea96f9411d17e6368a77eb3523bdddb6ff7d", + "local/RESIDUAL-ADAPTERS.json": "c4ddd4db13db5ed6b3672f8ddd0dc3a2bfff50068779b51489c6f002972f6163", + "local/SCALAR-FRAME-AUDIT.json": "faa10cbdafa561c412573c0562c9e747a7c67c9868c89e91f605a2bac57f2683", + "local/WARP-RECIPE-CHECKS.json": "e14580302b11eaed5e0d96a421935eef3b34fb10d9f8d9fc26d5364a30b2370b", + "local/WRAPPER-CHECKS.json": "2b8981d41893a2bbbed38ca78fcca7a0f613e50b062861c8f329bd47fa4d3485" + }, + "word_sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f" + } + }, + "retained_parent_receipt_sha256": "bc1bc13637846b3807119ae55dd006c8076815f355c93e0a1f57c1dce3ebeb3e", + "retained_reuse_receipt_sha256": "f90cafe84385533a0eeb96356f385b646f402ff85cd05154c47a81c783023d9d", + "reused_retained_native_count": 2, + "reused_retained_parent": true, + "source_commit": "pr3605-ac92a027c78b0c9bb0ada739b26959afda489d0e", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/staged-donor-release/sources/rational_price.py b/research/staged-donor-release/sources/rational_price.py new file mode 100644 index 0000000000..cc53a4ef64 --- /dev/null +++ b/research/staged-donor-release/sources/rational_price.py @@ -0,0 +1,77 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Rational enclosures for the finite paid-profile comparison. + +For 1<=x<2, log(x)=2*sum(z^(2j+1)/(2j+1)), z=(x-1)/(x+1). +The positive remainder is at most 2*z^(2n+1)/((2n+1)*(1-z*z)). +Range reduction gives z<=1/3. Alternating exponential partial sums then +bound exp(-a*log(r)); no floating arithmetic or root solver is used. +""" +from fractions import Fraction as Q +from functools import lru_cache + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def log_series(x, n=100): + z = (x - 1) / (x + 1) + total = Q(0) + power = z + for j in range(n): + total += 2 * power / (2*j + 1) + power *= z*z + tail = 2 * power / ((2*n + 1) * (1-z*z)) + return total, total + tail + + +@lru_cache(None) +def log_bounds(rank): + need(type(rank) is int and 1 <= rank <= 73, 'priced rank domain') + exponent = rank.bit_length() - 1 + a, b = log_series(Q(rank, 1 << exponent)) + c, d = log_series(Q(2)) + lo, hi = a + exponent*c, b + exponent*d + # Outward rational quantization keeps subsequent denominators bounded. + scale = 10**90 + low = (lo.numerator * scale) // lo.denominator + high = -((-hi.numerator * scale) // hi.denominator) + return Q(low, scale), Q(high, scale) + + +def exp_negative(x, degree): + need(0 <= x < 1, 'alternating exponential range') + term = Q(1) + total = term + for j in range(1, degree + 1): + term *= -x / j + total += term + return total + + +@lru_cache(None) +def h_bounds(rank, a): + need(Q(0) < a < Q(1, 100), 'exponent domain') + lo, hi = log_bounds(rank) + return rank * exp_negative(a*hi, 31), rank * exp_negative(a*lo, 30) + + +def interval(profile, a): + a = Q(a) + lower = upper = Q(0) + for r, count in profile.items(): + need(type(r) is int and type(count) is int, 'integer signed profile') + lo, hi = h_bounds(r, a) + lower += count * (lo if count >= 0 else hi) + upper += count * (hi if count >= 0 else lo) + return lower, upper + + +def compact(bounds): + # Report outward intervals at 60 decimal places, retaining rational signs. + lo, hi = bounds + scale = 10**60 + low = (lo.numerator*scale)//lo.denominator + high = -((-hi.numerator*scale)//hi.denominator) + return {'lower': str(Q(low, scale)), 'upper': str(Q(high, scale))} diff --git a/research/staged-donor-release/sources/staged_pair.py b/research/staged-donor-release/sources/staged_pair.py new file mode 100644 index 0000000000..ca3e3effb9 --- /dev/null +++ b/research/staged-donor-release/sources/staged_pair.py @@ -0,0 +1,86 @@ +"""Deterministic declared staged entrance edit; Python standard library only. + +The record contains every scalar edit and solved-frame preimage. This applier +does not search or optimize frames and derives inverse cleanup literally. +""" +import copy,gzip,hashlib,json,sys +from pathlib import Path + +def canonical(w): + return hashlib.sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def require(ok,why): + if not ok:raise ValueError(why) + +def cleanup(w): + n=2*w['report']['v']+w['report']['R'];rest=set(map(int,w['helper_final'])) + full=[256,128,64,32,16,8,4,2,1];fw=list(w['A'][w['prelude_events']:]);by={} + for op,rec in enumerate(w['warps'],1):by.setdefault(rec[0],[]).append(['warp',rec[1],op]) + for i in range(len(w['B'])+1): + fw+=by.get(i,[]) + if i