diff --git a/research/t74-joint-twelve-retired7/.gitattributes b/research/t74-joint-twelve-retired7/.gitattributes new file mode 100644 index 0000000000..f7e56e18b7 --- /dev/null +++ b/research/t74-joint-twelve-retired7/.gitattributes @@ -0,0 +1,2 @@ +# Preserve the exact bytes of every pinned and vendored file (the vendored PR2679 auditor keeps its CRLF lines). +* -text diff --git a/research/t74-joint-twelve-retired7/CLAIM.json b/research/t74-joint-twelve-retired7/CLAIM.json new file mode 100644 index 0000000000..2e64718924 --- /dev/null +++ b/research/t74-joint-twelve-retired7/CLAIM.json @@ -0,0 +1,49 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717794984118634663827", + "complex_upper": "0.001717794984118634663828", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": "2751", + "comparison_head": "4cfbb0cc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2751, + "head": "4cfbb0cc", + "exact_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000" + }, + "comparisons": { + "2751": { + "kappa_source": "evidence/PR2751-CLAIM.json", + "exact_margin": "326698885104162859/500000000000000000000000", + "margin_float": 6.533977702083258e-07 + }, + "2766": { + "kappa_source": "evidence/PR2766-CLAIM.json", + "exact_margin": "538010651632355557/1000000000000000000000000", + "margin_float": 5.380106516323556e-07 + }, + "2767": { + "kappa_source": "evidence/PR2767-OUTER-CLAIM.json", + "exact_margin": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)", + "margin_float": 5.380106516323556e-07 + } + }, + "new_contribution": "two hostee moves (the hostees of B-warps 30/31 move from lenders 401/403 onto the free retired lenders 564/565) that free 401/403 for two more retired-lender aliases 667<-401 and 669<-403, on top of the five retired-lender aliases 606<-550, 635<-551, 637<-552, 638<-553, 639<-562", + "credited_refit": "the certified frame refit of PR2751's words (B1151 rank 6->5 plus A0-A11, B771-788, restore60; per call H1 -2, H2 +1) is PR2766's (DavidAriasC); PR2767 (jeremykothe2) reaches the same kappa by another route", + "local_predecessor": { + "package": "research/t74-joint-twelve-retired5 (local, unpublished; branch t74-joint-twelve-retired5 b295183e)", + "exact_kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "exact_margin": "385667783143020379/1000000000000000000000000", + "margin_float": 3.856677831430204e-07 + } +} diff --git a/research/t74-joint-twelve-retired7/DERIVATIVE-CODE.patch b/research/t74-joint-twelve-retired7/DERIVATIVE-CODE.patch new file mode 100644 index 0000000000..15b163674a --- /dev/null +++ b/research/t74-joint-twelve-retired7/DERIVATIVE-CODE.patch @@ -0,0 +1,137 @@ +--- a/audit_mixed.py ++++ b/audit_mixed.py +@@ -9,7 +9,7 @@ + for _nm,_mut in (('changed lifted target frame',lambda b_:b_['target_levels'].__setitem__('23',0)),): + _bad=copy.deepcopy(w);_mut(_bad) + try:A.local_inventory(_bad,r,None) +- except ValueError as _e:A.require(str(_e)=='target line30','target mutation rejection') ++ except ValueError as _e:A.require(str(_e)=='candidate exact source-partner target frames','target mutation rejection') + else:raise ValueError('accepted changed lifted target') + _pg=A.read(d/'LOCAL-PROGRAMS.json.gz');_bp=copy.deepcopy(_pg);_bp['forward'].remove(next(e for e in _bp['forward'] if e[0]=='center')) + try:A.local_inventory(w,r,_bp) +--- a/independent_core.py ++++ b/independent_core.py +@@ -69,8 +69,7 @@ + External ports/frames are independently checked by audit_mixed.py. + """ + levels = {int(t): f for t, f in word['target_levels'].items()} +- require(set(levels) == {11,23,29,32,34,35,45,48,50,59,63,71,73,76,81,84,87,90,92,108}, 'twenty source-partner target offsets') +- require(all(frames[f] in ((30,), (45,)) for f in levels.values()), 'target line30') ++ require({str(t): list(frames[f]) for t, f in levels.items()} == {'104': [45], '106': [45], '110': [45], '14': [45], '21': [45], '37': [45], '41': [45], '43': [45], '47': [45], '52': [45], '78': [45], '99': [45]}, 'candidate exact source-partner target frames') + require(all(current[V+t] == frames[levels.get(t, 0)] for t in range(V)), 'target centre level') + forward, backward = [], [] + for index, (register, frame_id) in enumerate(zip(word['centers'], word['center_frames'])): +@@ -90,7 +89,7 @@ + origin = destination + forward.extend(segments) + backward.extend(e[:2]+[e[3], e[2], e[4]] for e in reversed(segments)) +- require(Counter(e[4] for e in forward) == {1:8, 7:8}, 'sixteen centre children') ++ require(Counter(e[4] for e in forward) == {8:8}, 'candidate eight unsplit centre children') + return {'forward': forward, 'backward': backward} + + +--- a/new/borrow/lowfour_controls.py ++++ b/new/borrow/lowfour_controls.py +@@ -20,12 +20,13 @@ + ia=next(i for i,e in enumerate(pre) if e[0]=='add') + m=mut();m['A'][ia][3]=-m['A'][ia][3];expect('prelude correction sign flipped',m) + m=mut();m['A'][ia][3]*=2;expect('prelude correction coefficient doubled',m) +- m=mut();m['A'][ia][1],m['A'][ia+1][1]=m['A'][ia+1][1],m['A'][ia][1];expect('prelude correction targets swapped',m) ++ jb=next(j for j,e in enumerate(pre) if e[0]=='add' and e[1]!=pre[ia][1] and e[2:]!=pre[ia][2:] and e[-1]==pre[ia][-1]) ++ m=mut();m['A'][ia][1],m['A'][jb][1]=m['A'][jb][1],m['A'][ia][1];expect('prelude correction targets swapped',m) + iw=[i for i,e in enumerate(pre) if e[0]=='warp'];m=mut();del m['A'][iw[1]];m['prelude_events']-=1;expect('prelude return warp dropped',m) + m=mut();del m['A'][iw[0]];m['prelude_events']-=1;expect('prelude forward warp dropped',m) +- ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==135];m=mut() ++ target=pre[ia][1];ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==target];assert ids;m=mut() + for i in reversed(ids):del m['A'][i] +- m['prelude_events']-=len(ids);expect('all prelude corrections of target 135 dropped',m) ++ m['prelude_events']-=len(ids);expect('all prelude corrections of actual first target dropped',m) + m=mut();m['A'][0][-1]=[31];expect('prelude target scale at a different line',m) + m=mut();m['A'][iw[0]][2]=m['A'][iw[0]][2]+1 if abs(m['A'][iw[0]][2])i:r[0]-=1 + expect('source restoration gate dropped (cleanup re-derived)',rederive(m)) + # rewritten helper gate on the borrowed source removed +- j=next(i for i,g in enumerate(w0['B']) if g[0]=='add' and g[1]==33 and g[2]==250) ++ j=next(i for i,g in enumerate(w0['B']) if i>=w0['warps'][W33][0] and g[0]=='add' and g[1]==33) + m=mut();del m['B'][j] + for r in m['warps']: + if r[0]>j:r[0]-=1 +--- a/new/code/borrow/bw_audit_local.py ++++ b/new/code/borrow/bw_audit_local.py +@@ -179,6 +179,17 @@ + def phase_at(es,name):return es.index(['phase',name]) + def first_warp(es,sign=1,start=0):return ev_index(es,lambda e:e[0]=='warp' and (e[2]>0)==(sign>0),start) + def cleanup_warp(es):return first_warp(es,-1,phase_at(es,'full_frame_cleanup')) ++def incomplete_centre_descent(es): ++ # Split paths lose an intermediate step. An unsplit path is truncated at ++ # an actual nested rank-one frame, with its child rank repriced correctly. ++ # Thus the control cannot fail merely because a split no longer exists. ++ indices=[i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0] ++ if indices: ++ es.pop(indices[0]);return ++ e=next(e for e in es if e[0]=='center') ++ stop=next(f for f in range(len(frames)) if len(frames[f])==1 and contains(frames[f],frames[e[2]])) ++ e[3]=stop;e[4]=len(frames[e[2]])-1 ++ + mutations=[ + ('wrong_scale',lambda es:next(e for e in es if e[0]=='scalar' and e[1][0]=='scale')[1].__setitem__(2,3)), + ('missing_center',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center'))), +@@ -194,7 +205,7 @@ + ('wrapper_on_a_centre_register',lambda es:next(e for e in es if e[0]=='residual_adapter').__setitem__(2,['C',0])), + ] if entering else [])+([ + ('centre_step_not_nested',lambda es:next(e for e in es if e[0]=='center').__setitem__(3,next(f for f in range(len(frames)) if not contains(frames[f],frames[next(e for e in es if e[0]=='center')[2]]) and not contains(frames[next(e for e in es if e[0]=='center')[2]],frames[f])))), +- ('centre_descent_step_skipped',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0))), ++ ('centre_descent_incomplete',incomplete_centre_descent), + ] if levels else [])+([ + ('hpe_pre_wrapper_resolved_to_full_recipe',lambda es:next(e for e in es if e[0]=='residual_adapter' and e[1]=='pre' and len(e)==5).pop()), + ('hpe_post_wrapper_without_terminal_frame',lambda es:next(e for e in es if e[0]=='residual_adapter' and len(e)==5).pop()), +--- a/new/rebuild_borrow.py ++++ b/new/rebuild_borrow.py +@@ -74,10 +74,10 @@ + lf=D/'inputs'/f'lowfour_43{wt}.json';lpatch=None + if lf.exists(): # four low aliases through lifted-target compensation (PR2436 mechanism) on top of the entrance state + lpatch=json.loads(lf.read_text());prev_l=chain[-1];chain.append(word_patch.apply_lowfour(prev_l,lpatch));steps.append('lowfour') +- nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[640,641,642,644]==lpatch['derived_removed_diff'] ++ nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[696,697,698,700]==lpatch['derived_removed_diff'] + kok&=[x[1:] for x in nw['warps'][:len(prev_l['warps'])]]==[x[1:] for x in prev_l['warps']] and [x[1] for x in nw['warps'][-4:]]==[33,55,74,85] and len(nw['warps'])==len(prev_l['warps'])+4 + kok&=[g[:-1] for g in nw['A'][nw['prelude_events']:]]==[g[:-1] for g in prev_l['A']] and nw['restore']==prev_l['restore'] and nw['helper_final']==prev_l['helper_final'] +- kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('640','641','642','644')}==nw['start_extra'] ++ kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('696','697','698','700')}==nw['start_extra'] + af=D/'inputs'/f'alias637_43{wt}.json';apatch=None + if af.exists(): # alias 637 borrowing retired source 31 (PR2436 pair) stacked on the four lifted-target aliases + apatch=json.loads(af.read_text());prev_a=chain[-1];chain.append(word_patch.apply_lowfour(prev_a,apatch));steps.append('alias637');na=chain[-1] +@@ -102,10 +102,10 @@ + kok&=word_patch.kernel_gate_edit(prev_p['B'],npl['B'])==ppatch['declared_gate_edit'] + kok&=all(npl[k_]==prev_p[k_] for k_ in ('A','precondition','cut','start_extra','target_levels','centers','center_frames','ports','prelude_events')) + rf2=D/'inputs'/f'refit563_43{wt}.json';rpatch2=None +- if rf2.exists(): # one-gate exact frame lowering (B 894, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) ++ if rf2.exists(): # one-gate exact frame lowering (B 904, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) + rpatch2=json.loads(rf2.read_text());prev_r=chain[-1];chain.append(refit_apply(prev_r,rpatch2));steps.append('refit563');nr=chain[-1] +- kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',894] and prev_r['B'][894][:5]==['add',515,563,1,1] +- kok&=len(nr['B'][894][-1])==len(prev_r['B'][894][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=894) ++ kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',904] and prev_r['B'][904][:5]==['add',515,563,1,1] ++ kok&=len(nr['B'][904][-1])==len(prev_r['B'][904][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=904) + kok&=not({515,563}&({x_['L'] for x_ in ppatch['pairs']}|{x_['h'] for x_ in ppatch['pairs']}) if ppatch else set()) + xf=D/'inputs'/f'alias1_43{wt}.json';xpatch=None + if xf.exists(): # retired-lender alias 653<-563 on the refit state (this package) +@@ -141,9 +141,9 @@ + pw_=Path(tempfile.mkdtemp())/'orig.json.gz';pw_.write_bytes(gzip.compress(json.dumps(prev_p,separators=(',',':')).encode(),mtime=0)) + pc=subprocess.run([sys.executable,'-B',str(D/'prelife_controls.py'),str(shipped),str(pw_),str(RCP/f'CONTROLS-PRELIFE-43{wt}.json')],capture_output=True,text=True) + pc_ok=pc.returncode==0 and json.loads((RCP/f'CONTROLS-PRELIFE-43{wt}.json').read_text())['all_rejected_for_expected_reason'];ok&=pc_ok;res['prelife_controls_ok']=pc_ok +- if rpatch2: # control: the shipped word with the B 894 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) ++ if rpatch2: # control: the shipped word with the B 904 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) + import copy as cp6 +- m=cp6.deepcopy(final);m['B'][894][-1]=prev_r['B'][894][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) ++ m=cp6.deepcopy(final);m['B'][904][-1]=prev_r['B'][904][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) + br=run_audit(bp,None,bp.parent/'refit563_undone.out.json');ru=br.returncode!=0 and 'warp frame mismatch' in (br.stdout+br.stderr);res['refit563_undone_rejected_by_warp_frame_mismatch']=ru;ok&=ru + if xpatch: + xc=subprocess.run([sys.executable,'-B',str(D/'alias1_controls.py'),str(shipped),str(xf),str(RCP/f'CONTROLS-ALIAS1-43{wt}.json')],capture_output=True,text=True) diff --git a/research/t74-joint-twelve-retired7/DERIVATIVE-OVERLAY.tar.gz b/research/t74-joint-twelve-retired7/DERIVATIVE-OVERLAY.tar.gz new file mode 100644 index 0000000000..8e2ac23939 Binary files /dev/null and b/research/t74-joint-twelve-retired7/DERIVATIVE-OVERLAY.tar.gz differ diff --git a/research/t74-joint-twelve-retired7/GENERATOR-PINS.json b/research/t74-joint-twelve-retired7/GENERATOR-PINS.json new file mode 100644 index 0000000000..53cbe5b14d --- /dev/null +++ b/research/t74-joint-twelve-retired7/GENERATOR-PINS.json @@ -0,0 +1,12 @@ +{ + "pr2679_manifest": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "vendor": { + "vendor/generate_words.py": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "vendor/gf_chart.py": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "vendor/target_transport.py": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "vendor/UPSTREAM-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "vendor/GENERATOR-NOTICE.txt": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "vendor/UPSTREAM-VENDOR-SOURCES.json": "592a98f6a3bd7fbd0063d90c989e30c5cd534220797b5b0beb0388e1f8d498ec", + "vendor/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } +} diff --git a/research/t74-joint-twelve-retired7/INPUT-PINS.json b/research/t74-joint-twelve-retired7/INPUT-PINS.json new file mode 100644 index 0000000000..db68544ada --- /dev/null +++ b/research/t74-joint-twelve-retired7/INPUT-PINS.json @@ -0,0 +1,41 @@ +{ + "inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11", + "inputs/FILL.json.gz": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "inputs/POSITIVE2462-base.json.gz": "3506c84203f126900326ff4d22aaceda819734e5f96fa4622d43fbb78b946ece", + "inputs/POSITIVE2462-extra.json.gz": "ec7103c196b32de7af79a6f43952cbe998c085a00f1a8e740f5556c774589099", + "inputs/PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06", + "inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7", + "inputs/WORD-base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "inputs/WORD-extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "evidence/PR2733-CLAIM.json": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "evidence/PR2745-CLAIM.json": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3", + "inputs/WORD2751-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "inputs/WORD2751-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "inputs/PROVIDERS2751.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "inputs/FILL2751.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "inputs/refit5_43base.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "inputs/refit5_43extra.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "inputs/alias5_43base.json": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "inputs/alias5_43extra.json": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "inputs/refit5c_43base.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "inputs/refit5c_43extra.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "evidence/PR2751-CLAIM.json": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438", + "vendor/word_patch_pr2679.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "evidence/PR2766-CLAIM.json": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8", + "evidence/PR2767-OUTER-CLAIM.json": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "vendor/audit_local_pr2679.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "inputs/refit7_43base.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "inputs/refit7_43extra.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "inputs/hostmove2_43base.json": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "inputs/hostmove2_43extra.json": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "inputs/alias7_43base.json": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "inputs/alias7_43extra.json": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "inputs/refit7c_43base.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "inputs/refit7c_43extra.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "retired7_controls.py": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904" +} diff --git a/research/t74-joint-twelve-retired7/LICENSE b/research/t74-joint-twelve-retired7/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/t74-joint-twelve-retired7/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/t74-joint-twelve-retired7/NOTICE b/research/t74-joint-twelve-retired7/NOTICE new file mode 100644 index 0000000000..4f946d9773 --- /dev/null +++ b/research/t74-joint-twelve-retired7/NOTICE @@ -0,0 +1,14 @@ + +research/t74-joint-twelve-retired7 + +Prepared by Marius-Paul Dumitrean with substantial AI assistance (Anthropic Claude, via Claude Code). Apache-2.0. + +This package derives from PR2751 (Tekalign, @tekuuu, Apache-2.0, with substantial OpenAI Codex assistance) and retains its +source notices unchanged in SOURCE-NOTICE. It contains the local retired5 construction (five retired-lender aliases 606<-550, +635<-551, 637<-552, 638<-553, 639<-562 with their exact refits, certified frames and stage inputs; RETIRED5-CODE.patch; +evidence/retired5) and adds the retired7 stages: two hostee moves (the PR2226 borrows of warps 30/31 move from lenders 401/403 +onto 564/565) enabling the retired-lender aliases 667<-401 and 669<-403, with their exact refits, certified frames, stage +inputs, compacted owner fill, checker adaptations (RETIRED7-CODE.patch), retired7_controls.py, verify_retired7.py and +evidence/retired7. Re-used mechanism: PR2679's retired-lender alias 653<-563 (Philippe Van Velzen). Frame refit of PR2751's +words included in the certified frames: PR2766 (DavidAriasC). Vendored byte-identical: vendor/audit_local_pr2679.py and +vendor/word_patch_pr2679.py from the pinned PR2679 package. diff --git a/research/t74-joint-twelve-retired7/OVERLAY-PINS.json b/research/t74-joint-twelve-retired7/OVERLAY-PINS.json new file mode 100644 index 0000000000..4c1a0ca6ee --- /dev/null +++ b/research/t74-joint-twelve-retired7/OVERLAY-PINS.json @@ -0,0 +1,43 @@ +{ + "original_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "derived_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "archive_sha256": "12335359418a2d75ff62ada3f868497590e025d5b39f6ee01f1a50f23c9768af", + "files": { + "MANIFEST.json": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "audit_mixed.py": "b8a319f580adf417384a13a996ca82ab674fae7917c2ae971aa4025bb2305e78", + "independent_core.py": "a747bf36a4c005398e71300005a5733bb9fa70fcdb0d00f306c894361c1b2a39", + "new/BORROW-PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "new/borrow-fill/FILL.json.gz": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "new/borrow-fill/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "new/borrow/inputs/alias1_43base.json": "20abad50afc6f75b01ba312687ef27c2ef3c41d8afc1429d8c8c8536384cf508", + "new/borrow/inputs/alias1_43extra.json": "df0739086556744574be9c574ae0cca3b1b7c1409d12647829999ffe9d3bed10", + "new/borrow/inputs/alias5_43base.json": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "new/borrow/inputs/alias5_43extra.json": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "new/borrow/inputs/alias7_43base.json": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "new/borrow/inputs/alias7_43extra.json": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "new/borrow/inputs/alias8_43base.json": "564a2576b3748847cbf5f0e9d22e4d96d159d65f654b5e02e317b05c186775dd", + "new/borrow/inputs/alias8_43extra.json": "9e437b3f6bd36f0e96bf41435a3698ffd42a17fb372492b144097bd59637d53c", + "new/borrow/inputs/hostmove2_43base.json": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "new/borrow/inputs/hostmove2_43extra.json": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "new/borrow/inputs/lowfour_43base.json": "9f80e059f3b68eaf2682b162110a75091df98e73eb8d70fb442e5c6fad3363e7", + "new/borrow/inputs/lowfour_43extra.json": "9a726ea6bfd3c7d1452377e4be70ab986195ee184f82eb754906def0d08606fc", + "new/borrow/inputs/prelife_43base.json": "77a9a5e0fdfefe861171e46d370d0797356d99e1302d0b2c676d7a619804216d", + "new/borrow/inputs/prelife_43extra.json": "4b2a805cb82d0c8036d7217979ffe1ff984d29b399066585c6b2502597a386f9", + "new/borrow/inputs/refit563_43base.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/inputs/refit563_43extra.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/inputs/refit5_43base.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "new/borrow/inputs/refit5_43extra.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "new/borrow/inputs/refit5c_43base.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "new/borrow/inputs/refit5c_43extra.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "new/borrow/inputs/refit7_43base.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "new/borrow/inputs/refit7_43extra.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "new/borrow/inputs/refit7c_43base.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "new/borrow/inputs/refit7c_43extra.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "new/borrow/lowfour_controls.py": "157d05da7842ba3939290e874cc9f784f351cbfc897275aa1f19a500532ce89d", + "new/borrow/retired7_controls.py": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904", + "new/borrow/words/BORROW-WORD-43base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "new/rebuild_borrow.py": "ab499d468d49b115af3c1e08b891e43d273e7d4cbd359e0b22d532c5ed253124" + } +} diff --git a/research/t74-joint-twelve-retired7/PROFILE.json b/research/t74-joint-twelve-retired7/PROFILE.json new file mode 100644 index 0000000000..c8b3bc8998 --- /dev/null +++ b/research/t74-joint-twelve-retired7/PROFILE.json @@ -0,0 +1,10 @@ +{ + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 +} diff --git a/research/t74-joint-twelve-retired7/PROOF.md b/research/t74-joint-twelve-retired7/PROOF.md new file mode 100644 index 0000000000..d2b1a96ba8 --- /dev/null +++ b/research/t74-joint-twelve-retired7/PROOF.md @@ -0,0 +1,25 @@ +# Changed recovery contract and complete moment + +The exact object is the two finite T74 words reconstructed by `generate.py`. The experiment uses a single explicit assignment, not a search over all assignments. Starting before PR2462's lowfour transformation is essential: applying the old lowfour patch first is a positive control reproducing its complete original words. + +The new `(removed helper, recovered source, partner)` assignments are: + +``` +(696,33,49), (697,55,101), (698,74,83), (700,85,98), +(680,49,33), (681,83,74), (682,98,85), (684,101,55), +(688,68,4), (689,80,88), (690,88,80), (692,31,12). +``` + +The last eight are PR2696's assignment. For each of the pairs33/49,55/101,74/83,85/98, let `(x,y)` denote the values after their last original uses, in their shared frame. The two added gates are `x += y/2` followed by `y -= x`, hence the linear map is `(x+y/2, y/2-x)`. For the actual predecessor state these restore the two original source values. The proof of that word-specific premise is the full arbitrary-input exact symbolic replay, not a claim that this map is the identity on arbitrary `(x,y)`. + +These restorations precede the new alias handoffs. Original operator IDs remain stable; twelve new chart transformations are appended. Removed-helper echoes are deleted only where they are target additions. For each new source, the generator computes the complete symbolic residual, transports its negative through precondition/compensation, and emits explicit initial correction gates and inverse source warps. Every residual must consist of a single new operator applied to its recovered source. Independent forward/dual propagation checks the resulting arbitrary-input identity, including dirty registers, and separately checks inverse cleanup. + +All lifted targets have frame `[45]`; their offsets are14,21,37,41,43,47,52,78,99,104,106,110. None is a target read by any cut gate. Actual frame propagation therefore leaves all eight centre children rank8. This changes the old-four recovery/target paths fixed in PR2720; its obstruction is respected within its stated domain. + +Apply the six PR2679 pre-life substitutions to the actual resulting state, refit the unique `515 += 563` gate (now B904), then alias653 into563. The complete generator checks semantic equality of both resulting words. The source-bound original checks and negative controls are rerun. No helper saving is inferred solely from nominal register labels. + +The complete local profile is `{1:2366,2:646,3:297,4:120,5:26,8:8}`. Compared with the PR2733 composition it changes by `4*(H8-H7-H1)` per local word. The same415-helper inventory admits the explicit complete allocation; `independent_owners.py` checks276390 roles, strict temporal windows, every physical cell, family masks and all remainders. There are666 call equivalents, giving global delta `2664*(H8-H7-H1)` and rank mass4816512 unchanged. + +At exponent `0 alias5 -> refit5c`. +2. **New here: two hostee moves that free two more lenders.** + - The hostees of B-warps 30 and 31 currently live on the lenders 401 and 403. Those lenders' own lives end in A, before + helpers 667 and 669 enter at B259 and B262. + - Each hostee moves onto a free retired lender: 401 -> 564 and 403 -> 565. Lenders 564 and 565 last act at B911 and B912, + before the hostees enter at B941 and B944. Each moved warp record is replaced in place, so op ids 30 and 31 are kept. + - This frees 401 and 403 for two more retired-lender aliases of PR2679's kind: **667<-401 and 669<-403**. + +**What makes the moves feasible.** An exact frame refit: the last gates of 564 and 565 are lowered from rank 6 to rank 5, which is +their exact propagated frame floor. The moved hostees enter at rank 5 already, so no follower raise is needed. The new aliases are +fixed-frame: lender frame dim 4 = follower entrance dim 4. The certified optimal frames of the final program also lower B1170/B1171, +the next gates of 504/505, from rank 6 to rank 5. + +**Exact claim.** The exact rational κ is `C - 10^-46 - 10^-70`, with `C = 0.001717794984118634663827` (in `CLAIM.json`). Larger κ is +better in `O(n (log n)^(1-κ))`. No selected frontier is edited, and PR2751's own directory is unchanged. + +| compared with | its exact κ (pinned in `evidence/`) | margin of this package | +|---|---|---| +| PR2751 (tekuuu) | `0.001717141586348426338109 - 10^-46 - 10^-70` | `+6.53397770208325718E-7` (exact `326698885104162859/500000000000000000000000`) | +| PR2766 (DavidAriasC) | `0.001717256973467002308270 - 10^-46 - 10^-70` | `+5.38010651632355557E-7` (exact `538010651632355557/1000000000000000000000000`) | +| PR2767 (jeremykothe2) | `0.0017172569734670023082709447…` (3000-digit outer claim) | `+5.38010651632355556055E-7` | +| retired5 (local, unpublished) | `0.001717409316335491643448 - 10^-46 - 10^-70` | `+3.85667783143E-7` | + +**What is new here, and what is credited.** +- The certified frames include PR2766's frame refit of PR2751's words, unchanged: B1151 rank 6 -> 5, plus A0-A11, B771-788 and + restore 60. PR2767 reaches the same κ by another route. +- The five retired-lender aliases are the retired5 construction, worth `+1.52342868489E-7` over PR2766/PR2767. +- The **new contribution of this package is the two hostee moves and the two aliases they enable**, worth `+3.85667783143E-7` over + retired5. + +## Reproduce + +From the repository root, with Python 3.12 and no third-party dependencies, run the registered hook. It completes in about two +minutes and is limited to 17 minutes: + +```sh +python3.12 -B scripts/research_package.py --package research/t74-joint-twelve-retired7 +``` + +It runs four commands: +- `verify.py`: PR2751's literal review, adapted below. It prints `PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY` and checks 271728 owner roles. +- `verify_retired7.py`: the seven-stage rebuild, the pinned PR2679 auditor on all eight states, 142 tamper controls, the literal owner + fill, the 80-digit root, and κ against PR2751, PR2766 and PR2767. +- `packing_cap.py`: the generic packing ceiling. +- `test_integrity.py`: relocation and fail-closed controls. + +Full cold release: install `requirements.txt`, then use a fresh directory outside the repository: + +```sh +python3 -B research/t74-joint-twelve-retired7/full_replay.py --source /path/to/pr2679/research/gmx-t74-borrow43-handoff --work /tmp/FRESH-retired7 +``` + +Without `--source`, the 491 pinned PR2679 files are downloaded and authenticated, exactly as in PR2751. The run then: +- applies this package's 36-file overlay: PR2751's 21 files, retired5's six stage inputs, the eight retired7 stage inputs and + `new/borrow/retired7_controls.py`; +- builds four fresh native providers and the retained-parent admission; +- runs the complete admission: owner reconstruction, parent lift, rebind, discovery/unpin/freeze at PR2751's 24-digit endpoint + precision, the outer ledger and the package's own `verify_release.py` (strict T74 replay and all controls). + +Expected result: `PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE 0.0017177949841186346638269999999999999999999998999999999999999999999999` (recorded cold run of the committed package: 411 s; see `evidence/retired7/FULL-REPLAY-RESULT.json`). +`--prepared-native-cache` is not supported: `REUSE-PINS.json` is PR2751's and describes PR2751's cache. + +To regenerate all four words (PR2751's two, then this package's two through the declared stages) from source: + +```sh +python3 -B research/t74-joint-twelve-retired7/generate.py --source /path/to/pr2679/research/gmx-t74-borrow43-handoff --out /tmp/FRESH-retired7-words +``` + +Expected: `PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS`. + +## Construction and cost + +**Census** (on the retired5 words, with PR2679's exact frame lattice `new/borrow/refit/search` and the `pairs.py` rule): +- 52 followers remain. 48 enter at rank 1 (width 8) and 4 at rank 4 with ceiling 5 (width 5): 667, 669, 670 and 671. There are 404 + lenders, and no direct pair or chain is feasible. +- Every rank-1 follower stays infeasible, because every lender's exact floor is at least rank 4. +- Every existing B-warp hosting is treated as movable. 24 hosted lenders (warps 1-4 and 22-41) end their own lives before B259, with + floor rank 4, and could take a rank-4 follower if their hostee moves to a free lender. Only two free lenders have floor <= 5 and + retire before the hostees enter: 564 and 565. +- That gives 192 augmenting paths and at most **two** extra aliases. +- Warps 30 and 31 are chosen because their hostees already enter at rank 5. Moves of warps 1-4 or 22-29 need a 16-gate raise closure + and price lower. + +**Stages.** These are new stages of `new/rebuild_borrow.py` inside the overlay, run after retired5's `refit5c`: +- `refit7_43*.json`: two frames per word. The last gates of 564/565 (B911/B912) go from dim 6 to 5, recorded with their previous frames. +- `hostmove2_43*.json`: two warp records replaced in place (op 30: 401 -> 564 at B941; op 31: 403 -> 565 at B944; dim 5, explicit + invertible `G`, `G(U)=E`), and 28 declared gate edits, which relabel the 14 hostee gates. Nothing else changes. +- `alias7_43*.json`: `alias_build.alias` 667<-401 and 669<-403, with dim 4 warps appended, 28 declared gate edits, and both helpers removed. +- `refit7c_43*.json`: the certified optimal frames of the final program, two frames (B1170/B1171, dim 6 -> 5), computed with the + #1186 exact frame toolkit (`optimal_frames`, borrow-word model, certified). + +Every one of the eight states passes the auditor. + +**Inventory and profile.** +- 408 helpers {4:26, 5:2, 7:62, 8:78, 9:240}, 72 private buffers, 666 calls and 271728 hosted roles. +- live 66304; physical 66794 = 66304+408+8+72+2. +- Local profile `{1:2382,2:648,3:268,4:128,5:26,8:8}` on both words, against `{1:2386,2:642,3:274,4:128,5:26,8:8}` for retired5. + +**Owner fill.** It is PR2751's fill with the seven removed helpers' roles dropped, renumbered and re-tiled as bin prefixes (`verify.py` +`compact`). The 1332 cells freed beyond retired5 become idle 5-remainders. +- Complete profile `{1:1603728,2:431568,3:185082,4:85248,5:27194,8:5328,32:1,48:26558}`; rank mass 4816512; idle `{1:17316,3:6594,5:9878,32:1,48:26558}`. +- The pattern relaxation of the owner fill (8/16/32/48 bins, the r8 model) has the same optimum as this realized compaction. +- The exact moment root lies strictly between `0.001717794984118634663827` and `0.001717794984118634663828`. +- The 80-digit root is `0.00171779498411863466382722991842817890408858438546231220090092725676198114516931`. + +**Packing ceiling.** The generic coverage-law ceiling (`packing_cap.py`, the pinned `ceiling.ceiling()`) is about `0.00175808593463`, +with realized fraction `0.9770824908`. It is a packing cap, not a sharp optimum. + +## Checker adaptations (diffs in `RETIRED7-CODE.patch`; the retired5 adaptations are in `RETIRED5-CODE.patch`) + +1. **`verify.py`.** The candidate profile and endpoint are re-pinned. The declared stage chain gains `refit7 -> hostmove2 -> alias7 -> refit7c`. + The compaction now removes seven helpers: the five retired5 ones plus 667 and 669. +2. **`verify_retired7.py`** (replaces `verify_retired5.py`). It adds the retired7 stage-structure checks and audits all eight states. + It also runs `retired7_controls.py`, 25 controls per word, on top of retired5's 46 per word. The owner fill size is R 408. +3. **`retired7_controls.py`** (new; also in the overlay as `new/borrow/retired7_controls.py`, called by `rebuild_borrow.py`). Every + mutant has its inverse-reverse cleanup re-derived, and a rejection for a stale-cleanup reason counts as a failure. The controls are: + - each lender refit undone, which must be rejected by `warp frame mismatch`; + - per move: warp lender reverted, move undone, warp before the new lender retires, and `G` wrong; + - PR2679's alias suite on each new alias: borrowed read sign flipped, read doubled, write sign flipped, warp dropped, `G` wrong, + warp after the follower's first gate, and helper kept with an entrance frame. "Warp after the first gate" replaces "warp before + lender retirement", because these lenders retire in A, which leaves no B position before retirement; + - one certified frame corrupted. +4. **`workflow/admit.py`.** + - The derived-source pin is `9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451`, with 506 files instead of 497. + - The physical stock is 66794 instead of 66796 (R 408). +5. **`new/rebuild_borrow.py`** (overlay). It has the four stages with exact structure checks, and the retired7 controls call. + +`generate.py`, `packing_cap.py` and `test_integrity.py` change only the stage list, the expected candidate values and the markers. +`independent_owners.py` is unchanged from retired5: it reads `R` from the providers. + +## Verification and controls + +**Full cold release.** `evidence/retired7/FULL-REPLAY-*.json`. +- All four native providers are fresh, with five stages each. +- The retained-parent admission passed. +- The complete admission passed: owners, parent lift, rebind, discovery, outer ledger and independent derivation. +- The package's own `verify_release.py` returned `PASS_RELEASE`. Its `rebuild-borrow-words` stage includes the retired5 and + retired7 stage checks and controls. + +**Registered hook.** It repeats the seven-stage rebuild with the vendored, byte-identical PR2679 auditor and all 142 tamper controls, +plus the literal owner fill and the exact arithmetic. + +**Precision.** The endpoint is certified at `10^-24`: accept at `C`, reject at `C+10^-24`, with exact rationals. That is 16 orders of +magnitude below the `3.86e-7` margin over retired5. κ = `C - 10^-46 - 10^-70` exactly. + +## Scope and inherited obligations + +Finite exact admission is conditional evidence, not a formal proof of the complete multiplication theorem. The following remain +inherited from PR2751 and its lineage unchanged: +- all-size compiler and machine realization; +- common labels and source access; +- physical hosting and routing; +- precision and fixed-tape contracts; +- exact recovery and analytic transfer; +- recurrence; +- the bit-supplier and modern outer obligations. + +No new discharge of those universal obligations is claimed. The selected accepted result and this pending derivative are distinct. +The census searched retired-lender aliases, with every existing B-warp hosting movable onto a free retired lender. No optimality is +claimed over other mechanisms. + +## Credits + +- **Tekalign (@tekuuu), PR2751:** the joint twelve-source construction, words, fill transform, independent checkers and full replay (the parent). +- **Cinna Davis (1337isnot1337), PR2226:** anticipatory dirty borrowing. Warps 30/31 are its borrows: helpers 603 and 605 borrow + from lenders 401 and 403, as adapted to the T74 words. +- **Philippe Van Velzen (philippeVV), PR2679 (and PR2559):** the six pre-life hostings, the one-gate frame refit and the retired-lender + alias 653<-563, which is the mechanism re-used for all seven aliases; also the exact refit/search frame tools and the alias builder. +- **Jeremy Kothe (jeremykothe2), PR2673/PR2745:** + - the priority call order and window-optimal owner fill; + - the composition of PR2696 with PR2679; + - the gmx-t74-borrow43 package machinery, entrance raises and BORROW-WORD lineage (PR2588, PR2575, PR2526, PR2474, PR2462, PR2447, + PR2435), including the T74 adaptation of PR2226's borrows and the base-word lenders 564/565. +- **Mason Hale, PR2696:** the eight-lender assignment. +- **DavidAriasC, PR2766:** the frame refit of PR2751's words, which is included in the certified frames. +- **Vlado Vojdanovski (Vlado-V), PR2322:** the coherent handoff. +- **Our PR1625:** the pivot-kernel shape. **Our PR1186:** the exact frame toolkit. **Our retired5 package:** the five aliases. + +All notices and the lineage these packages retain are kept: see `SOURCE-NOTICE`, PR2751's `README.md` and `PROOF.md`. + +## Open next questions + +1. **Gate-level edits.** Can a gate-level (kernel) edit make the 48 rank-1-entrance followers alias-feasible? Every lender's exact floor is at least rank 4. +2. **Followers 670 and 671.** Both still lack a lender: the only free floor-5 lenders (564/565) are used by the moves. A third free + lender would need a frame floor of at most 5 and retirement before B941. +3. **Stacking with PR2767.** Do these stages stack with PR2767's post-cut partner correction, or with other post-PR2751 constructions? + +Prepared by Marius-Paul Dumitrean with substantial AI assistance (Anthropic Claude, via Claude Code). Apache-2.0. diff --git a/research/t74-joint-twelve-retired7/RETIRED5-CODE.patch b/research/t74-joint-twelve-retired7/RETIRED5-CODE.patch new file mode 100644 index 0000000000..732313f3ca --- /dev/null +++ b/research/t74-joint-twelve-retired7/RETIRED5-CODE.patch @@ -0,0 +1,260 @@ +--- research/t74-joint-twelve/verify.py ++++ research/t74-joint-twelve-retired5/verify.py +@@ -15,6 +15,30 @@ + import exact_moment as M + HERE=Path(__file__).resolve().parent +-PROFILE={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +-LOW=F('0.001717141586348426338109') ++PROFILE={1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} ++LOW=F('0.001717409316335491643448') ++PROFILE2751={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} ++LOW2751=F('0.001717141586348426338109') ++ALIASES=[(606,550),(635,551),(637,552),(638,553),(639,562)] # retired5 ++import importlib.util as _iu ++_s=_iu.spec_from_file_location('word_patch_pr2679',Path(__file__).resolve().parent/'vendor/word_patch_pr2679.py');WP=_iu.module_from_spec(_s);_s.loader.exec_module(WP) ++def refit_apply(w0,p): ++ w=copy.deepcopy(w0) ++ for sec,i,fr in p['frames']: ++ need(w[sec][i][:-1]==w0[sec][i][:-1],'refit changes a gate');w[sec][i][-1]=fr ++ w['report']['local_profile']=p['local_profile'];return w ++def compact(fill,old_words,new_words,old_prov,new_prov,order,dispatch): ++ live=lambda w:[r for r in range(224,704) if r not in set(w['removed'])] ++ L0=live(old_words['gauge44']);L1=live(new_words['gauge44']);need(L0==live(old_words['extra']) and L1==live(new_words['extra']),'live helper sets') ++ gone=set(L0)-set(L1);need(set(L1)<=set(L0) and sorted(gone)==sorted(h for h,_ in ALIASES),'removed helpers') ++ i1={r:i for i,r in enumerate(L1)};bins={} ++ for pid in ('gauge44','extra'):need([old_prov[pid]['widths'][L0.index(r)] for r in L1]==new_prov[pid]['widths'],'renumbered widths') ++ for t,h,o,c,p,off in fill['rows']: ++ if L0[h] in gone:continue ++ bins.setdefault((o,c,p),[]).append([t,i1[L0[h]],o,c,p,off]) ++ rows=[] ++ for key,rs in bins.items(): ++ rs.sort(key=lambda x:x[5]);pos=0 ++ for x in rs:x[5]=pos;pos+=new_prov[dispatch[tuple(order[x[0]])]]['widths'][x[1]];rows.append(x) ++ rows.sort(key=lambda x:(x[0],x[1]));return dict(fill,rows=rows) + def need(ok,msg): + if not ok:raise ValueError(msg) +@@ -29,6 +53,6 @@ + need(F(claim['complex_lower'])==LOW and F(claim['complex_upper'])==LOW+F(1,10**24),'claim bracket') + need(F(claim['kappa'])==LOW-F(1,10**46)-F(1,10**70),'claim outer endpoint') +- for name in ('PR2733','PR2745'): +- previous=json.loads((HERE/'evidence'/f'{name}-CLAIM.json').read_text()) ++ for name in ('PR2733','PR2745','PR2751','PR2766','PR2767'): ++ previous=json.loads((HERE/'evidence'/(f'{name}-OUTER-CLAIM.json' if name=='PR2767' else f'{name}-CLAIM.json')).read_text()) + need(F(claim['kappa'])>F(previous['kappa']),'strict improvement over '+name) + words={} +@@ -49,6 +73,16 @@ + dispatch={(s,r):p for s,r,p in rd('DISPATCH.json.gz')} + need(order==rd('SOURCE-ORDER.json'),'source order') +- constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),providers,rd('SOURCE-FILL.json.gz'),order,dispatch,words) +- need(constructed==fill,'complete deterministic fill') ++ # retired5: PR2751's own construction (its words, providers and fill) is reproduced first ... ++ words51={'gauge44':rd('WORD2751-base.json.gz'),'extra':rd('WORD2751-extra.json.gz')};prov51=rd('PROVIDERS2751.json');fill51=rd('FILL2751.json.gz') ++ constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),prov51,rd('SOURCE-FILL.json.gz'),order,dispatch,words51) ++ need(constructed==fill51,'complete deterministic PR2751 fill') ++ # ... then the declared stages turn its words into the candidate words exactly ... ++ for tag,pid in [('base','gauge44'),('extra','extra')]: ++ w=refit_apply(words51[pid],rd('refit5_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias5_43'+tag+'.json'));w=refit_apply(w,rd('refit5c_43'+tag+'.json')) ++ need(w==words[pid],'declared stages reproduce the candidate word '+tag) ++ d2=dict(dispatch) ++ for s,r,p in fill['dispatch_overrides']:d2[s,r]=p ++ # ... and the candidate fill is PR2751's fill with the five removed helpers' roles dropped, renumbered and re-tiled as bin prefixes ++ need(compact(fill51,words51,words,prov51,providers,order,d2)==fill,'complete deterministic candidate fill') + owner=I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,fill,providers,dispatch,PROFILE) + bad=copy.deepcopy(fill);bad['rows'][0][5]=999 +@@ -57,6 +91,5 @@ + else:raise ValueError('accepted out-of-bin placement') + _,a=M.moment_bounds(PROFILE,LOW);b,_=M.moment_bounds(PROFILE,LOW+F(1,10**24));need(a<6630466304,'PR2733 rejects candidate endpoint') +- return {'status':'PASS_JOINT_TWELVE_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} ++ x,_=M.moment_bounds(PROFILE2751,LOW);need(x>66304,'PR2751 rejects candidate endpoint') ++ return {'status':'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} + if __name__=='__main__':print(json.dumps(run(),indent=2)) +--- research/t74-joint-twelve/independent_owners.py ++++ research/t74-joint-twelve-retired5/independent_owners.py +@@ -67,11 +67,12 @@ + need(set(dispatch)==set(map(tuple,order)),'dispatch coverage') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns') +- need(len(fill['rows'])==666*415,'role count') +- need(all(len(p['widths'])==415 for p in providers.values()),'helper widths') ++ R=len(next(iter(providers.values()))['widths']) # retired5: helper count from the providers (was 415) ++ need(len(fill['rows'])==666*R,'role count') ++ need(all(len(p['widths'])==R for p in providers.values()),'helper widths') + helper_bits=[0]*666;family_bits=[0]*666;occupied={} + for row in fill['rows']: + need(len(row)==6 and all(type(v) is int for v in row),'role shape') + t,h,o,c,port,offset=row +- need(0<=t<666 and 0<=h<415 and 0<=port<112,'role bounds') ++ need(0<=t<666 and 0<=h previous, ++ need(kappa == C-Q(1,10**70)-Q(1,10**46) and kappa > previous and kappa > Q('17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000'), # retired5: also strictly above PR2751 + 'candidate must strictly improve pinned COMPOSED before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') +--- research/t74-joint-twelve/generate.py ++++ research/t74-joint-twelve-retired5/generate.py +@@ -45,5 +45,15 @@ + w,_=AB.alias(w,653,563);lp,wi=AB.profile(w);w['report'].update(local_profile=lp,width_inventory=wi) + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') +- need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated word equality') +- print('PASS_REGENERATED_JOINT_TWELVE_BOTH_WORDS') ++ need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') ++ # retired5: the declared stages refit5 -> alias5 -> refit5c turn the regenerated PR2751 word into the candidate word ++ for st in ('refit5','alias5','refit5c'): ++ p_=rd(HERE/f'inputs/{st}_43{tag}.json') ++ if st=='alias5':w=W.apply_lowfour(w,p_) ++ else: ++ w=copy.deepcopy(w) ++ for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st=='refit5c','refit gate');w[sec][i][-1]=frame ++ w['report']['local_profile']=p_['local_profile'] ++ f=out/f'WORD-retired5-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired5-{tag}.json') ++ need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') ++ print('PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS') + if __name__=='__main__':main() +--- research/t74-joint-twelve/packing_cap.py ++++ research/t74-joint-twelve-retired5/packing_cap.py +@@ -11,7 +11,7 @@ + sys.dont_write_bytecode = True + ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +-IDLE = {1:17316,3:6594,5:5216,32:1,48:26558} +-CANDIDATE = {1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +-ENDPOINT = Q('0.001717141586348426338109') ++IDLE = {1:17316,3:6594,5:8546,32:1,48:26558} ++CANDIDATE = {1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} ++ENDPOINT = Q('0.001717409316335491643448') + + def need(ok, message): +@@ -28,7 +28,7 @@ + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} +- need(local == {1:2366,2:646,3:297,4:120,5:26,8:8}, 'complete local profile') ++ need(local == {1:2386,2:642,3:274,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) +- need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5223, 'coverage identity') ++ need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5198, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') +--- research/t74-joint-twelve/test_integrity.py ++++ research/t74-joint-twelve-retired5/test_integrity.py +@@ -10,9 +10,9 @@ + def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + def main(): +- with tempfile.TemporaryDirectory(prefix='joint-twelve-controls-') as t: ++ with tempfile.TemporaryDirectory(prefix='joint-twelve-retired5-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) +- r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') ++ r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') +--- PR2751 overlay: new/rebuild_borrow.py ++++ retired5 overlay: new/rebuild_borrow.py +@@ -1,3 +1,3 @@ +-"""rebuild_borrow.py: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), ++"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls]: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), + check they equal the shipped borrow/words byte-for-content, run the extended auditor (borrow/audit_local.py) and its negative controls. + usage: python -B rebuild_borrow.py [--no-controls] (exit 0 only if everything passes)""" +@@ -121,4 +121,35 @@ + (RCP/f'ALIAS-ENUMERATION-43{wt}.json').write_text(json.dumps(dict(prelife_refit_state=dict(counts=s0,pairs=[{k_:x_[k_] for k_ in('h','L','p1','d','s','f1','width','dprof')} for x_ in e0]),shipped=dict(counts=s1,pairs=len(e1)), + note='counts: h_used_in_A_or_early = helpers first used before B (needs the prelude/lifted-target mechanism); the other counts are (h,L) pairs failing that condition'),indent=1)+'\n') ++ A5=[(606,550),(635,551),(637,552),(638,553),(639,562)];H5=[h_ for h_,_ in A5];L5=[L_ for _,L_ in A5] ++ def regs_(e_):return e_[1:3] if e_[0]=='add' else e_[1:2] ++ def frames_only(x,y): # same gate lists in A/B/restore, every other field equal (report aside); returns the changed (section,index) set ++ assert all(len(x[k_])==len(y[k_]) and all(a_[:-1]==b_[:-1] for a_,b_ in zip(x[k_],y[k_])) for k_ in ('A','B','restore')) ++ assert all(x[k_]==y[k_] for k_ in x if k_ not in ('A','B','restore','report')) and set(x)==set(y) ++ return {(k_,i_) for k_ in ('A','B','restore') for i_,(a_,b_) in enumerate(zip(x[k_],y[k_])) if a_!=b_} ++ r5f=D/'inputs'/f'refit5_43{wt}.json';r5patch=None ++ if r5f.exists(): # retired5: exact minimal-change refit for five retired-lender aliases (refit/search: lenders' last gates to their exact floors, followers' first gates to their exact ceilings) ++ r5patch=json.loads(r5f.read_text());prev_r5=chain[-1];chain.append(refit_apply(prev_r5,r5patch));steps.append('refit5');nr5=chain[-1] ++ try:ch5=frames_only(prev_r5,nr5);kok&=ch5=={(s_,i_) for s_,i_,_ in r5patch['frames']} ++ except AssertionError:kok=False ++ lastL={L_:max(p_ for p_,e_ in enumerate(prev_r5['B']) if L_ in regs_(e_)) for L_ in L5};firstH={h_:min(p_ for p_,e_ in enumerate(prev_r5['B']) if h_ in regs_(e_)) for h_ in H5} ++ kok&=all(lastL[L_]66304,'PR2751 rejects candidate endpoint') +- return {'status':'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} ++ return {'status':'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} + if __name__=='__main__':print(json.dumps(run(),indent=2)) +diff --git a/packing_cap.py b/packing_cap.py +index 435b62e..fe937f8 100644 +--- a/packing_cap.py ++++ b/packing_cap.py +@@ -11,7 +11,7 @@ HERE = Path(__file__).resolve().parent + sys.dont_write_bytecode = True + ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +-IDLE = {1:17316,3:6594,5:8546,32:1,48:26558} +-CANDIDATE = {1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} +-ENDPOINT = Q('0.001717409316335491643448') ++IDLE = {1:17316,3:6594,5:9878,32:1,48:26558} ++CANDIDATE = {1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} ++ENDPOINT = Q('0.001717794984118634663827') + + def need(ok, message): +@@ -28,7 +28,7 @@ def calculate(profile_path=None): + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} +- need(local == {1:2386,2:642,3:274,4:128,5:26,8:8}, 'complete local profile') ++ need(local == {1:2382,2:648,3:268,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) +- need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5198, 'coverage identity') ++ need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5188, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') +diff --git a/generate.py b/generate.py +index 7c6f2dc..dafca20 100644 +--- a/generate.py ++++ b/generate.py +@@ -46,14 +46,14 @@ def main(): + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') +- # retired5: the declared stages refit5 -> alias5 -> refit5c turn the regenerated PR2751 word into the candidate word +- for st in ('refit5','alias5','refit5c'): ++ # retired5 + retired7: the declared stages refit5 -> alias5 -> refit5c -> refit7 -> hostmove2 -> alias7 -> refit7c turn the regenerated PR2751 word into the candidate word ++ for st in ('refit5','alias5','refit5c','refit7','hostmove2','alias7','refit7c'): + p_=rd(HERE/f'inputs/{st}_43{tag}.json') +- if st=='alias5':w=W.apply_lowfour(w,p_) ++ if st in ('alias5','hostmove2','alias7'):w=W.apply_lowfour(w,p_) + else: + w=copy.deepcopy(w) +- for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st=='refit5c','refit gate');w[sec][i][-1]=frame ++ for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st in ('refit5c','refit7','refit7c'),'refit gate');w[sec][i][-1]=frame + w['report']['local_profile']=p_['local_profile'] +- f=out/f'WORD-retired5-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired5-{tag}.json') ++ f=out/f'WORD-retired7-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired7-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') +- print('PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS') ++ print('PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS') + if __name__=='__main__':main() +diff --git a/test_integrity.py b/test_integrity.py +index 85d1f86..eedb99e 100644 +--- a/test_integrity.py ++++ b/test_integrity.py +@@ -10,9 +10,9 @@ def need(ok,msg): + def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + def main(): +- with tempfile.TemporaryDirectory(prefix='joint-twelve-retired5-controls-') as t: ++ with tempfile.TemporaryDirectory(prefix='joint-twelve-retired7-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) +- r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') ++ r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') +diff --git a/workflow/admit.py b/workflow/admit.py +index 37dc6e3..282ff24 100644 +--- a/workflow/admit.py ++++ b/workflow/admit.py +@@ -23,5 +23,5 @@ import time + + SOURCE_COMMIT = 'local-joint12-pr2733' +-SOURCE_MANIFEST = '0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3' # retired5 derived source: PR2751 overlay + five retired-lender aliases ++SOURCE_MANIFEST = '9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' # retired7 derived source: PR2751 overlay + five retired-lender aliases + two hostee moves and two aliases + PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' + PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +@@ -70,5 +70,5 @@ def main(): + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') +- need(len(source_files) == 497 and tree(source, ('MANIFEST.json',)) == source_files, ++ need(len(source_files) == 506 and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + native_receipt = read(a.native_receipt) +@@ -170,5 +170,5 @@ def main(): + natives['extra'] / 'local', work / 'rebound') + spec = read(work / 'rebound/SPEC.json') +- need(spec['expected']['physical'] == 66796, 'complete physical cost including 72 buffers (R 410)') ++ need(spec['expected']['physical'] == 66794, 'complete physical cost including 72 buffers (R 408)') + layout = work / 'layout' + layout.mkdir() +diff --git a/verify_retired5.py b/verify_retired7.py +index 720b3e1..0f2c1ee 100644 +--- a/verify_retired5.py ++++ b/verify_retired7.py +@@ -2,8 +2,10 @@ + # SPDX-License-Identifier: Apache-2.0 + # Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +-"""Bounded replay of the five retired-lender aliases on PR2751's words (read-only, standard library only). ++# retired7 extension of verify_retired5.py (same author). ++"""Bounded replay of retired7 on PR2751's words: the five retired-lender aliases (retired5 stages) plus two hostee moves that free ++two more retired lenders (retired7 stages refit7 -> hostmove2 -> alias7 -> refit7c). Read-only, standard library only. + +-1. Rebuilds both candidate words from PR2751's words through the three declared stages (refit5, alias5, refit5c) and checks +- each stage's declared structure exactly. ++1. Rebuilds both candidate words from PR2751's words through the seven declared stages (refit5, alias5, refit5c, refit7, hostmove2, ++ alias7, refit7c) and checks each stage's declared structure exactly. + 2. Runs the pinned PR2679 BORROW-WORD auditor (vendor/audit_local_pr2679.py, byte-identical) on every state. + 3. Tamper controls, each rejected by that auditor for a real reason: every lender refit undone (warp frame mismatch), every +@@ -21,4 +23,6 @@ sys.dont_write_bytecode = True + sys.path.insert(0, str(HERE)) + ALIASES = [(606, 550), (635, 551), (637, 552), (638, 553), (639, 562)] ++MOVES = [(30, 401, 564, 911), (31, 403, 565, 912)] # retired7: (warp op, old lender, new lender, new lender's last B gate) ++NEW7 = [(667, 401), (669, 403)] + H5 = [h for h, _ in ALIASES]; L5 = [L for _, L in ALIASES] + def need(ok, msg): +@@ -45,5 +49,5 @@ def main(): + need(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == digest, 'vendored source pin ' + name) + AU = load('audit_local_pr2679', HERE / 'vendor/audit_local_pr2679.py'); WP = load('word_patch_pr2679', HERE / 'vendor/word_patch_pr2679.py') +- import independent_owners as I, exact_moment as M ++ import independent_owners as I, exact_moment as M, retired7_controls as R7 + tmp = Path(tempfile.mkdtemp(prefix='retired5-')) + def audit(w, name): +@@ -72,6 +76,30 @@ def main(): + need(all(s2[k] == s1[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias5 changes nothing else') + s3 = refit_apply(s2, p3); ch3 = frames_only(s2, s3); need(ch3 == {(s, i) for s, i, _ in p3['frames']}, 'refit5c declared frames') +- need(s3 == final, 'declared stages rebuild the candidate word ' + tag) +- for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('candidate', s3))): ++ p4, p5, p6, p7 = (rd(f'inputs/{n}_43{tag}.json') for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')) ++ s4 = refit_apply(s3, p4); ch4 = frames_only(s3, s4); need(ch4 == {('B', g) for _, _, _, g in MOVES} == {(s, i) for s, i, _ in p4['frames']}, 'refit7 declared frames') ++ need(all(len(s3['B'][g][-1]) == 6 and len(s4['B'][g][-1]) == 5 and L1 in regs(s3['B'][g]) and max(p for p, e in enumerate(s3['B']) if L1 in regs(e)) == g for _, _, L1, g in MOVES), 'new lenders: last gates lowered 6 -> 5') ++ need(not any(L1 in regs(e) for _, _, L1, _ in MOVES for e in s3['restore']) and p4['previous_frames'] == [[s, i, s3[s][i][-1]] for s, i, _ in p4['frames']], 'new lenders retired; previous frames recorded') ++ s5 = WP.apply_lowfour(s4, p5) ++ need(WP.kernel_gate_edit(s4['B'], s5['B']) == p5['declared_gate_edit'] and s5['removed'] == s4['removed'] and s5['start_extra'] == s4['start_extra'], 'hostmove2 declared edit') ++ for i, (a, b) in enumerate(zip(s4['B'], s5['B'])): ++ c = list(a) ++ for op, L0, L1, _ in MOVES: ++ if i >= s4['warps'][op - 1][0]: c = [L1 if (j in (1, 2) if c[0] == 'add' else j == 1) and x == L0 else x for j, x in enumerate(c)] ++ need(c[:-1] == b[:-1], 'hostmove2 is exactly the relabel of the hostees from their warp positions') ++ need([i for i, (x, y) in enumerate(zip(s4['warps'], s5['warps'])) if x != y] == [op - 1 for op, _, _, _ in MOVES] and len(s5['warps']) == len(s4['warps']), 'hostmove2 replaces exactly warps 30 and 31 in place') ++ need(all(s4['warps'][op - 1][1] == L0 and s5['warps'][op - 1][1] == L1 and len(s5['warps'][op - 1][3]) == len(s5['warps'][op - 1][4]) == 5 and s5['warps'][op - 1][0] > g for op, L0, L1, g in MOVES), 'moved warps: new lenders, dim 5, after the lenders retire') ++ need([[m['pos'], m['L_new'], m['G'], m['U'], m['E']] for m in p5['moves']] == [s5['warps'][op - 1] for op, _, _, _ in MOVES] and [m['old_record'] for m in p5['moves']] == [s4['warps'][op - 1] for op, _, _, _ in MOVES], 'hostmove2 records') ++ need(all(not any(L0 in regs(e) for e in s5['B'] + s5['restore']) for _, L0, _, _ in MOVES), 'old lenders untouched after their A lives') ++ need(all(s5[k] == s4[k] for k in ('A', 'restore', 'helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'hostmove2 changes nothing else') ++ s6 = WP.apply_lowfour(s5, p6); H7 = [h for h, _ in NEW7]; L7 = [L for _, L in NEW7] ++ need(WP.kernel_gate_edit(s5['B'], s6['B']) == p6['declared_gate_edit'] and s6['removed'] == s5['removed'] + H7, 'alias7 declared edit and removed helpers') ++ need(s6['warps'][:len(s5['warps'])] == s5['warps'] and [x[1] for x in s6['warps'][len(s5['warps']):]] == L7 and all(len(x[3]) == len(x[4]) == 4 for x in s6['warps'][-2:]), 'alias7 warps') ++ need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p6['aliases']] == s6['warps'][-2:] and [a['h'] for a in p6['aliases']] == H7 and s6['A'] == s5['A'] and s6['restore'] == s5['restore'], 'alias7 records') ++ need(all(max([p for p, e in enumerate(s5['B']) if L in regs(e)], default=-1) < min(p for p, e in enumerate(s5['B']) if h in regs(e)) for h, L in NEW7) and not any(L in regs(e) for L in L7 for e in s5['restore']), 'alias7 lenders retired before their followers enter') ++ need(s6['start_extra'] == {k: v for k, v in s5['start_extra'].items() if int(k) not in H7} and not any(h in regs(e) for h in H7 for e in s6['B'] + s6['restore']), 'alias7 helpers fully removed') ++ need(all(s6[k] == s5[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias7 changes nothing else') ++ s7 = refit_apply(s6, p7); ch7 = frames_only(s6, s7); need(ch7 == {(s, i) for s, i, _ in p7['frames']}, 'refit7c declared frames') ++ need(s7 == final, 'declared stages rebuild the candidate word ' + tag) ++ for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('retired5', s3), ('refit7', s4), ('hostmove2', s5), ('alias7', s6), ('candidate', s7))): + r = audit(w, f'{tag}-{name}'); need(r is None, f'auditor rejects {tag} {name}: {r}') + c = {} +@@ -99,5 +127,7 @@ def main(): + need(r is not None and not r.split(': ', 1)[-1].startswith(('explicit cleanup differs', 'warp operator id')), f'{tag} {h}<-{L} {nm}: not rejected for a real reason: {r}') + sec, i, fr = p3['frames'][len(p3['frames']) // 2]; m = copy.deepcopy(final); m[sec][i][-1] = [1]; r = audit(m, f'{tag}-refit5c-tamper'); c['certified frame corrupted'] = r; need(r is not None, f'{tag} refit5c tamper accepted') +- out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), local_profile=final['report']['local_profile']) ++ ok7, c7 = R7.controls(final, p4, p5, p6, p7, lambda w: audit(w, f'{tag}-r7'), WP); need(ok7, f'{tag} retired7 controls: ' + json.dumps({k: v['reason'] for k, v in c7.items() if not v['real_reason']})[:300]) ++ c.update({k: v['reason'] for k, v in c7.items()}) ++ out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), refit7_frames=len(ch4), hostmove2_gate_edits=len(p5['declared_gate_edit']), alias7_gate_edits=len(p6['declared_gate_edit']), refit7c_frames=len(ch7), retired7_controls=len(c7), local_profile=final['report']['local_profile']) + out['controls'][tag] = {k: v[:90] for k, v in c.items()} + # literal owner check of the complete candidate fill +@@ -106,5 +136,5 @@ def main(): + profile = {int(k): v for k, v in rd('CLAIM.json')['profile'].items()} + owner = I.check(rd('inputs/PLAN.json.gz'), rd('inputs/GLOBAL-TEMPLATE.json.gz'), order, fill, providers, dispatch, profile) +- need(owner['roles'] == 666 * 410 and owner['helpers_per_call'] == 410, 'owner fill size') ++ need(owner['roles'] == 666 * 408 and owner['helpers_per_call'] == 408, 'owner fill size') + # exact endpoint and kappa + claim = rd('CLAIM.json'); C = F(claim['complex_lower']) +@@ -122,5 +152,5 @@ def main(): + k = F(rd(rel)['kappa']); need(K > k, 'strict improvement over ' + name); d = K - k + margins[name] = dict(decimal=str(Decimal(d.numerator) / Decimal(d.denominator))[:40], exact=str(d) if len(str(d)) < 120 else 'K - kappa(' + rel + ')') +- out.update(status='PASS_T74_JOINT_TWELVE_RETIRED5_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), ++ out.update(status='PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), + complex_lower=str(C), root_80_digits=str(+z)[:82], kappa=str(K), margins=margins, + scope='Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py).') +diff --git a/new/rebuild_borrow.py b/new/rebuild_borrow.py +index d7cac67..157c371 100644 +--- a/new/rebuild_borrow.py ++++ b/new/rebuild_borrow.py +@@ -1,3 +1,3 @@ +-"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls]: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), ++"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls; retired7: + refit7/hostmove2/alias7/refit7c stages and controls]: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), + check they equal the shipped borrow/words byte-for-content, run the extended auditor (borrow/audit_local.py) and its negative controls. + usage: python -B rebuild_borrow.py [--no-controls] (exit 0 only if everything passes)""" +@@ -152,4 +152,48 @@ for canon,wt,h in CASES: + try:chc=frames_only(prev_c5,nc5);kok&=chc=={(s_,i_) for s_,i_,_ in r5cpatch['frames']} + except AssertionError:kok=False ++ M7=[(30,401,564,911),(31,403,565,912)];N7=[(667,401),(669,403)];H7=[h_ for h_,_ in N7];L7=[L_ for _,L_ in N7] # retired7: hostee moves (warp op, old lender, new lender, new lender's last B gate) and two new aliases ++ def relabel_ok(x,y,pairs): # y's B section is x's with old->new lender relabelled from each pair's start, nothing else ++ for i_,(a_,b_) in enumerate(zip(x,y)): ++ c_=list(a_) ++ for st_,o_,n_ in pairs: ++ if i_>=st_: ++ if c_[0]=='add':c_[1]=n_ if c_[1]==o_ else c_[1];c_[2]=n_ if c_[2]==o_ else c_[2] ++ elif c_[1]==o_:c_[1]=n_ ++ if c_[:-1]!=b_[:-1]:return False ++ return len(x)==len(y) ++ r7f=D/'inputs'/f'refit7_43{wt}.json';r7patch=None ++ if r7f.exists(): # retired7: the free retired lenders 564/565 get their last gates (B911/B912) at the exact frame floor, dim 6 -> 5 ++ r7patch=json.loads(r7f.read_text());prev_r7=chain[-1];chain.append(refit_apply(prev_r7,r7patch));steps.append('refit7');nr7=chain[-1] ++ try:ch7=frames_only(prev_r7,nr7);kok&=ch7=={('B',g_) for _,_,_,g_ in M7}=={(s_,i_) for s_,i_,_ in r7patch['frames']} ++ except AssertionError:kok=False ++ kok&=all(len(prev_r7['B'][g_][-1])==6 and len(nr7['B'][g_][-1])==5 and L1_ in regs_(prev_r7['B'][g_]) and max(p_ for p_,e_ in enumerate(prev_r7['B']) if L1_ in regs_(e_))==g_ for _,_,L1_,g_ in M7) ++ kok&=not any(L1_ in regs_(e_) for _,_,L1_,_ in M7 for e_ in prev_r7['restore']) and r7patch['previous_frames']==[[s_,i_,prev_r7[s_][i_][-1]] for s_,i_,_ in r7patch['frames']] ++ h7f=D/'inputs'/f'hostmove2_43{wt}.json';h7patch=None ++ if h7f.exists(): # retired7: the hostees of warps 30/31 (lenders 401/403, whose own lives end in A) move onto 564/565; warp records replaced in place ++ h7patch=json.loads(h7f.read_text());prev_h7=chain[-1];chain.append(word_patch.apply_lowfour(prev_h7,h7patch));steps.append('hostmove2');nh7=chain[-1] ++ kok&=word_patch.kernel_gate_edit(prev_h7['B'],nh7['B'])==h7patch['declared_gate_edit'] and nh7['removed']==prev_h7['removed'] and nh7['start_extra']==prev_h7['start_extra'] ++ kok&=relabel_ok(prev_h7['B'],nh7['B'],[(prev_h7['warps'][op_-1][0],L0_,L1_) for op_,L0_,L1_,_ in M7]) ++ kok&=[i_ for i_,(x_,y_) in enumerate(zip(prev_h7['warps'],nh7['warps'])) if x_!=y_]==[op_-1 for op_,_,_,_ in M7] and len(nh7['warps'])==len(prev_h7['warps']) ++ kok&=all(prev_h7['warps'][op_-1][1]==L0_ and nh7['warps'][op_-1][1]==L1_ and len(nh7['warps'][op_-1][3])==len(nh7['warps'][op_-1][4])==5 for op_,L0_,L1_,_ in M7) ++ kok&=[[m_['pos'],m_['L_new'],m_['G'],m_['U'],m_['E']] for m_ in h7patch['moves']]==[nh7['warps'][op_-1] for op_,_,_,_ in M7] and [m_['old_record'] for m_ in h7patch['moves']]==[prev_h7['warps'][op_-1] for op_,_,_,_ in M7] ++ kok&=all(not any(L0_ in regs_(e_) for e_ in nh7['B']+nh7['restore']) for _,L0_,_,_ in M7) and all(nh7['warps'][op_-1][0]>g_ for op_,_,_,g_ in M7) ++ kok&=all(nh7[k_]==prev_h7[k_] for k_ in ('A','restore','helper_final','compensation','initial_corrections','precondition','cut','target_levels','centers','center_frames','ports','prelude_events')) ++ a7f=D/'inputs'/f'alias7_43{wt}.json';a7patch=None ++ if a7f.exists(): # retired7: retired-lender aliases 667<-401 and 669<-403 (the PR2679 kind) after the hostee moves ++ a7patch=json.loads(a7f.read_text());prev_a7=chain[-1];chain.append(word_patch.apply_lowfour(prev_a7,a7patch));steps.append('alias7');na7=chain[-1] ++ kok&=word_patch.kernel_gate_edit(prev_a7['B'],na7['B'])==a7patch['declared_gate_edit'] and na7['removed']==prev_a7['removed']+H7 ++ kok&=relabel_ok(prev_a7['B'],na7['B'],[(min(p_ for p_,e_ in enumerate(prev_a7['B']) if h_ in regs_(e_)),h_,L_) for h_,L_ in N7]) ++ kok&=na7['warps'][:len(prev_a7['warps'])]==prev_a7['warps'] and [x_[1] for x_ in na7['warps'][len(prev_a7['warps']):]]==L7 and all(len(x_[3])==len(x_[4])==4 for x_ in na7['warps'][-2:]) ++ kok&=[[a_['pos'],a_['L'],a_['G'],a_['U'],a_['E']] for a_ in a7patch['aliases']]==na7['warps'][-2:] and [a_['h'] for a_ in a7patch['aliases']]==H7 ++ kok&=all(max([p_ for p_,e_ in enumerate(prev_a7['B']) if L_ in regs_(e_)],default=-1) None (accepted) or the rejection reason; returns (all_ok, results)""" ++ def rederive(m): ++ m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(w0)); m2['A'] = A; return m2 ++ res = {} ++ def expect(name, m, reason=None, fresh=True): ++ r = audit(rederive(m) if fresh else m) ++ ok = r is not None and not r.split(': ', 1)[-1].startswith(VACUOUS) and (reason is None or reason in r) ++ res[name] = dict(rejected=r is not None, reason=(r or '')[:160], real_reason=ok) ++ need = audit(w0); assert need is None, ('unmutated final word rejected', need) ++ for sec, i, fr in p7['previous_frames']: ++ m = copy.deepcopy(w0); m[sec][i][-1] = fr; expect(f'refit7 {sec}{i} lender refit undone', m, 'warp frame mismatch') ++ for mv in ph['moves']: ++ k = mv['op'] - 1; tag = f"move{mv['op']} {mv['L_old']}->{mv['L_new']}" ++ m = copy.deepcopy(w0); m['warps'][k][1] = mv['L_old']; expect(tag + ' warp lender reverted', m) ++ m = copy.deepcopy(w0); m['warps'][k] = copy.deepcopy(mv['old_record']); relabel(m, mv['old_pos'], mv['L_new'], mv['L_old']); expect(tag + ' move undone', m) ++ m = copy.deepcopy(w0); m['warps'][k][0] = mv['pos'] - 400; expect(tag + ' warp before lender retirement', m) ++ m = copy.deepcopy(w0); m['warps'][k][2][0] ^= m['warps'][k][2][1]; expect(tag + ' G wrong', m) ++ for a in pa['aliases']: ++ h, L = a['h'], a['L']; op = next(i for i, r in enumerate(w0['warps']) if r[1] == L and r[0] == a['pos']); tag = f'{h}<-{L}' ++ reads = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] ++ writes = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] ++ m = copy.deepcopy(w0); m['B'][reads[0]][3] *= -1; expect(tag + ' borrowed read sign flipped', m) ++ m = copy.deepcopy(w0); m['B'][reads[0]][3] *= 2; expect(tag + ' borrowed read doubled', m) ++ if writes: m = copy.deepcopy(w0); m['B'][writes[0]][3] *= -1; expect(tag + ' borrowed write sign flipped', m) ++ m = copy.deepcopy(w0); del m['warps'][op] ++ for e in m['A'][:m['prelude_events']]: ++ if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 ++ expect(tag + ' warp dropped', m) ++ m = copy.deepcopy(w0); m['warps'][op][2][0] ^= m['warps'][op][2][1]; expect(tag + ' G wrong', m) ++ m = copy.deepcopy(w0); m['warps'][op][0] = a['pos'] + 1; expect(tag + " warp after the follower's first gate", m) ++ m = copy.deepcopy(w0); m['start_extra'][str(h)] = a['E']; expect(f'{h} kept with an entrance frame', m) ++ sec, i, fr = pc['frames'][0]; m = copy.deepcopy(w0); m[sec][i][-1] = [1]; expect('refit7c certified frame corrupted', m, fresh=False) ++ return all(r['real_reason'] for r in res.values()), res ++if __name__ == '__main__': ++ here = Path(__file__).resolve().parent; sys.path.insert(0, str(here)) ++ import audit_local as al, word_patch as WP ++ w0 = json.loads(gzip.decompress(Path(sys.argv[1]).read_bytes())); D = Path(sys.argv[2]); tag = sys.argv[3]; tmp = Path(tempfile.mkdtemp()) ++ p = {n: json.loads((D / f'{n}_43{tag}.json').read_text()) for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')} ++ def audit(w): ++ q = tmp / 'm.json.gz'; q.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode())) ++ try: ++ with contextlib.redirect_stdout(io.StringIO()): al.run(q, tmp / 'm.out.json', None, None) ++ return None ++ except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as e: ++ return (type(e).__name__ + ': ' + str(e))[:200] ++ ok, res = controls(w0, p['refit7'], p['hostmove2'], p['alias7'], p['refit7c'], audit, WP) ++ Path(sys.argv[4]).write_text(json.dumps(dict(all_rejected_for_real_reasons=ok, controls=res), indent=1) + '\n') ++ print(('ALL RETIRED7 CONTROLS REJECTED' if ok else 'RETIRED7 CONTROL FAILURE'), sum(r['real_reason'] for r in res.values()), 'of', len(res)); sys.exit(0 if ok else 1) diff --git a/research/t74-joint-twelve-retired7/REUSE-PINS.json b/research/t74-joint-twelve-retired7/REUSE-PINS.json new file mode 100644 index 0000000000..ff0b83bf69 --- /dev/null +++ b/research/t74-joint-twelve-retired7/REUSE-PINS.json @@ -0,0 +1,200 @@ +{ + "cache_files": { + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/CACHE.json": "134bdacc4a766dbc67df01704d4a279e29c0bea56350c75b2a0436b9ba8666d0", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/STEPS.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CANONICAL-WORD.json.gz": "dacaaa72961e8bcfefa5f5125aa79b2bae33d4faead01a651bd44a8ea5ab2412", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CLIFFORD-RECIPES.json": "a9641c6cbc4e05677e7559bf1764468f3dbcd9efe0ae710205590c381f6b5f08", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CLIFFORD-REVIEW.json": "9622789fd43d2c3e14d98ae3df48765d1faeb8f5664136f48384dcd603e215fe", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/FULL-WORD.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/INDEPENDENT-LOCAL-REPLAY.json": "1ca177b1b78a0faaaaeeb05d44ccef50810d20d9f5607b3fa7dd493067f69ef1", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/SCALAR-FRAME-AUDIT.json": "abbfa5baf5228072679d6ac08b873115ef3a00c39e6632e110d1f94a5f7657da", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/WARP-RECIPE-CHECKS.json": "32c3480dd0f953237f567a5e1c66eb15de9cee5b57c219b571bcc9cb993042dd", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/native.log": "8ac1d92e1e84f39a5865ae78d0894249995335c1734a450a53ce65998b59d57b", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/phases.log": "4f02722e71e03c4998f7c5b625ed5a7afdc7500ebfb0aa7e6f53b177cc08a645", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/CACHE.json": "069df513a95cdc93095aaecf5714ea2183c1735cc5bec65bd38e469adccdbff6", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/STEPS.json": "4637ff6d5767aae404ccc9251bef35e5961afa2ba2fd846527b93dca05c5fd2d", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/ledgers.log": "8a5910fbfadd88e164b84d65115ca356a932df55501dbbc9e102333b17688e77", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CANONICAL-WORD.json.gz": "c0fc324db76506cd9f0f88d830f28b8d18a0870a6dbcd31362e01f2683ffc065", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CLIFFORD-RECIPES.json": "d3efa2a7199bb2113f8232bb0e78deb8144f44856d6b03a1069e75d775245d6b", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CLIFFORD-REVIEW.json": "76a38ecba56ecdb28bc60ea8558a535533e5da6ead2de4fce92e80949e93ee0a", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/FULL-WORD.json.gz": "4f980df67440c0d0b87186b88a816301896f277068bec0295b67a5c06f43e8bd", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/INDEPENDENT-LOCAL-REPLAY.json": "1503f00082d7f94f6ac1765a143fcdf6e780f9e4a19d4cb018ce8f1930b009f4", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/LOCAL-CHECKS.json": "d9743b22c746403097ac2e4430f8c0c3edca6a325a1b14c7978fb94b2047b890", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/LOCAL-PROGRAMS.json.gz": "5f89cf546f6d5969a065256404a3c902c52217f3b79bddd740e33058907cdf16", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/RESIDUAL-ADAPTERS.json": "82f5e5cf37c8ec3cce707e7d152b23f6fff2fddd771ff43317b5a446ef81fc00", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/SCALAR-FRAME-AUDIT.json": "dd659103a97b2313c947f4ab6a44ef5dc6244e9cef57864d2cc1cc7d232ae6d7", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/WARP-RECIPE-CHECKS.json": "9ccdb18e1c1eb5a8f386d17b08a36e6b4338a34b15e49e9509acd2e866c12ee8", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/WRAPPER-CHECKS.json": "727c9a1dd1c85a6ced726f1ff03ff7399bd6a20db5ce53faf452ad242da73a5c", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/native.log": "99f4a9ed755532566debf2ec91da35981093f02538691889ca4201c266ae7194", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/phases.log": "27e8e39b604d3422bf02ad3512aa1301b1686fc81e3ab3b56d6e501129f58037", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "78a3b23d31d62f6fec7bfd448c0062dcacabd0e0e416957ce506839e94fb0eb7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "6b18a21ef3bfb8e96d26d60f2db702eb9e4e5fd4aae5f5113380074235ed85c4", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "16fa3177ea9496dea606f56623dfd69a1799075ec8bb9bba6258e35b7d865481", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "e6d01761d6a48c6d0e861194ba13515002e3d9ea6ac1b531b359bff5b2ed2459", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "b23f983d52700ff84a5d2303916f6e9a909937d301e4a308204702e756e9635c", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "633faa7fd015f93a5b6193598c45e70c41838655b4ad60b5ea98dbdedf601390", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "9f1805608ebc5fc68a4758cc781f37deb26490a800077357b7a91f1436a38872", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "03b6a2503949708d090f5338006662172324fe66502452e8da0c3b1454b27262", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "88c98295140810288ff552fdc8cfc3741b11ee6d80ce01e8d2c8f2c9b7a73e31", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "c7b917a0a452672d08f817a57eea0db1cf237c142371936e9f483f28f4428e54", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "a9c86b5209f35cad3be26f74f70a4962c48f3cb7021c696621beb1794d5c1278", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "e00871b9295253310a4145ebb4786af72a347a0a6015590c4779a29e20826608", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "2a58e55283a5d74adf38a8c4b78f21793b619ee885ccf64dc18af7b0d5f8a96d", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/CACHE.json": "41cc27c91f3610959ef3166a90484bd65bce0c663b420ecee0fd42725af2ca2c", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/STEPS.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CANONICAL-WORD.json.gz": "dd1f277eafbde7fbc68c51fad396a64e8afe389a8529bbe61e187014a8a48215", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CLIFFORD-RECIPES.json": "3fad1a9ae138ddb89442753cb2ef3c0666c58f40d5488d503fbf75f7f480d4d3", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CLIFFORD-REVIEW.json": "255cf6f3d1105e9c60e2b589e3445a6b7e69af575abcfe4f6a0aba971fdb4195", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/FULL-WORD.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/INDEPENDENT-LOCAL-REPLAY.json": "26adad9d1cd317e8e6c2f5db0f42e5f35ef4220e84280c80ac273aa2a329903a", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/SCALAR-FRAME-AUDIT.json": "10347acf893d70592ca4af8ee1cdf58a06510a444992feffcddf5c03bdf63e42", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/WARP-RECIPE-CHECKS.json": "95bc1e29bae8210542423d7b0d6b4c07b29d3948a2c987507a97cf085f963252", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/native.log": "0da891ab0e4bfeb32b3b73fbc03b0456ffb06e159906b2013938ad65e13b0585", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/phases.log": "cb01cc9d0f1831fc202ee5ab21ed9ccbcef52a3c369b7ca1390b64d99f070ecc", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/CACHE.json": "29b075f5e59eaea78a3d8386f8be8485fdac4629404087ca57f8d8a6505fb18f", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/STEPS.json": "6bec0227ce64490c9e6384464d9a8a778c54755a67f3a276c279faafb7a02981", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/ledgers.log": "8a5910fbfadd88e164b84d65115ca356a932df55501dbbc9e102333b17688e77", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CANONICAL-WORD.json.gz": "52c263e6936b4dd1eb009617e5df5fd0f39cae44e06683904194223d34052262", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CLIFFORD-RECIPES.json": "afc22bbc53821f3d4412afa81fa787be68672395a3432fed3c3740bb7708f4bb", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CLIFFORD-REVIEW.json": "8793f34c12e30884e17caefc7c898f83fe06ec6a07578c9783fed325d6db48a4", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/FULL-WORD.json.gz": "56252cf9c875ca56f5dee42c38c838fa0320662ff7f724a15f06145ff5cd5854", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/INDEPENDENT-LOCAL-REPLAY.json": "4139c7bd22c3cf55e58749f81b0013b7e824fdd82c3c701921a23fb2391db990", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/LOCAL-CHECKS.json": "d9743b22c746403097ac2e4430f8c0c3edca6a325a1b14c7978fb94b2047b890", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/LOCAL-PROGRAMS.json.gz": "5f89cf546f6d5969a065256404a3c902c52217f3b79bddd740e33058907cdf16", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/RESIDUAL-ADAPTERS.json": "ba41be347d33fad9b5d6af16457e92dd9ee507dc4589bafc63a903986e733d2c", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/SCALAR-FRAME-AUDIT.json": "a96f78833f2e7285ed8248510bf091c86c2918d3df4413307b83136231bdd406", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/WARP-RECIPE-CHECKS.json": "0fa3b603d74af3c9853df200e0ae3a0e71f910e1c3620415b7072f5553d7b918", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/WRAPPER-CHECKS.json": "727c9a1dd1c85a6ced726f1ff03ff7399bd6a20db5ce53faf452ad242da73a5c", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/native.log": "d4d096f7186024d29f919438ae4a25d50f157f642a2b84f6202851b1d768ee03", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/phases.log": "e6dbb20f1bdc7a8b014b307066e8598a365aae6e65701ab16b3a3c242a2bb907", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "56cbbc829163f32f3b2a3b6c413b8202aff367cfacd57fb88a1b9b7cf0c3470d", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "a5c02d0d6347aefd558e287fa581362a9b89adfd7eaf4a1c003dae47e1b1874e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "d0eb80da0f54f7444421c577a688e28cebc23d4abd8e431f5bf38526d3335d77", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "303767d1ff2550e4a10443b0d5ed705a8461c76f06bb7074762c02a0f54f339b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e6bafd6741e865e85b9ad8941b87b7c4e4c4a7debb78cd256e12a4b39ec3b586", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "32096efe8e8b986247bb8f434cee48cd29e209d2602125683ca91dbac242fa44", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "1f91b781e43e70b24ff14f2007cb767d30a9520411d222e49d7870981043dfb2", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "8945a81137262aa1ee8e2cf159dbd59838b58adf4b2f66a812a92406088111ed", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "44ae449a4ab0ea50c4bd377b38c12e4c73b5858391304e38d7f8bf46171b8866", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "458754a81eeabcd677a30b4c3e5a8393d7535bc21e02d4b0c75f3732d362c944", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "providers": { + "base": { + "R": 415, + "complete_native_files": { + "STEPS.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "local/CANONICAL-WORD.json.gz": "dd1f277eafbde7fbc68c51fad396a64e8afe389a8529bbe61e187014a8a48215", + "local/CLIFFORD-RECIPES.json": "3fad1a9ae138ddb89442753cb2ef3c0666c58f40d5488d503fbf75f7f480d4d3", + "local/CLIFFORD-REVIEW.json": "255cf6f3d1105e9c60e2b589e3445a6b7e69af575abcfe4f6a0aba971fdb4195", + "local/FULL-WORD.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "local/INDEPENDENT-LOCAL-REPLAY.json": "26adad9d1cd317e8e6c2f5db0f42e5f35ef4220e84280c80ac273aa2a329903a", + "local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12", + "local/SCALAR-FRAME-AUDIT.json": "10347acf893d70592ca4af8ee1cdf58a06510a444992feffcddf5c03bdf63e42", + "local/WARP-RECIPE-CHECKS.json": "95bc1e29bae8210542423d7b0d6b4c07b29d3948a2c987507a97cf085f963252", + "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native.log": "0da891ab0e4bfeb32b3b73fbc03b0456ffb06e159906b2013938ad65e13b0585", + "phases.log": "cb01cc9d0f1831fc202ee5ab21ed9ccbcef52a3c369b7ca1390b64d99f070ecc", + "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa" + }, + "fresh_stage_seconds": 316.8524922529905, + "paid_profile": { + "1": 2374, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 8 + }, + "widths": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "word_sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "zero_buffers": 72 + }, + "extra": { + "R": 415, + "complete_native_files": { + "STEPS.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "local/CANONICAL-WORD.json.gz": "dacaaa72961e8bcfefa5f5125aa79b2bae33d4faead01a651bd44a8ea5ab2412", + "local/CLIFFORD-RECIPES.json": "a9641c6cbc4e05677e7559bf1764468f3dbcd9efe0ae710205590c381f6b5f08", + "local/CLIFFORD-REVIEW.json": "9622789fd43d2c3e14d98ae3df48765d1faeb8f5664136f48384dcd603e215fe", + "local/FULL-WORD.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "local/INDEPENDENT-LOCAL-REPLAY.json": "1ca177b1b78a0faaaaeeb05d44ccef50810d20d9f5607b3fa7dd493067f69ef1", + "local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352", + "local/SCALAR-FRAME-AUDIT.json": "abbfa5baf5228072679d6ac08b873115ef3a00c39e6632e110d1f94a5f7657da", + "local/WARP-RECIPE-CHECKS.json": "32c3480dd0f953237f567a5e1c66eb15de9cee5b57c219b571bcc9cb993042dd", + "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native.log": "8ac1d92e1e84f39a5865ae78d0894249995335c1734a450a53ce65998b59d57b", + "phases.log": "4f02722e71e03c4998f7c5b625ed5a7afdc7500ebfb0aa7e6f53b177cc08a645", + "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa" + }, + "fresh_stage_seconds": 320.795613839, + "paid_profile": { + "1": 2374, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 8 + }, + "widths": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "word_sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "zero_buffers": 72 + } + }, + "retained_parent_receipt_sha256": "a9c86b5209f35cad3be26f74f70a4962c48f3cb7021c696621beb1794d5c1278", + "scope": "Both changed PR2679 native providers freshly executed all five stages. Exact retained PR1297 native providers and full parent-admission receipt reused from the authenticated earlier cache; all cache files pinned.", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/SOURCE-FILES.json b/research/t74-joint-twelve-retired7/SOURCE-FILES.json new file mode 100644 index 0000000000..7e8a64069e --- /dev/null +++ b/research/t74-joint-twelve-retired7/SOURCE-FILES.json @@ -0,0 +1,501 @@ +{ + "base_url": "https://raw.githubusercontent.com/philippeVV/integer-mult-bounds/2e2cf56521df8a2b816b2689144765ee00b69a24/research/gmx-t74-borrow43-handoff/", + "commit": "2e2cf56521df8a2b816b2689144765ee00b69a24", + "count": 491, + "files": { + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "ADMISSION-DERIVATION.patch": "7021000d75635fc5806af821640c02f9d7cbbbe1cf314dacfcc743fc6875fdd8", + "CLAIM.json": "bc893bde9d0605e793844dca14e8f8e175b839b890c6f9c15e3a147f6db0cb36", + "CONSTRUCTION.json": "ff5c0516714e3220468b84583ec0bb25d39c0832a179268b929699e5b1bd5508", + "DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "EXACT-ARITHMETIC-DERIVATION.json": "c0d40deaa495a7365e91aa5d9e6a846f91e0cb6daff98bb3b7f2acef84d64ec4", + "GLOBAL-TEMPLATE.json.gz": "1d31424c4e27e26a35a9932ca778e43f1f3577589275422cc642aa68b31112db", + "NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "ORDER.json": "e37e607973be543331ce19a3ee49f79ea22cda484a3dcdcf897719412db221be", + "OWNERS.json.gz": "e5a46f423debb846c49f8ed97202ba3919d417e237e22cb7b805c1df592e0e1d", + "PARENT-LIFT-RECEIPT.json": "cea858499dceda9dd6a77ebd1b39cf4598b237b1701cc01841481f2ebc4b5d33", + "PLAN.json": "abc47a9fffdb2079de0386a50c43b0f71f705f59fe71d3f9683031b4357560ce", + "PRICE.json": "c5ec535fd9edbdec7b64edd5a8b862edb1a7f173d411dacb279172659573e16a", + "PROFILE.json": "0dd9a8afa9eb343a12cab29bca16b2579c2ab4bec50ab7a1c539b20ae5d265ac", + "README.md": "7bbef7c9ebf7a1dbee4df8956a54fe799a0e2682935c6d919388be22e8254f5a", + "RELEASE.json": "2a4f17684f0e2666313b8e13c90e92640880164a8dc2a9d9396fe375aae0ece4", + "SOURCE-PIN-REFINEMENT.json": "8c0bad79978decd6f8aba0932c0a94c7f61c64bf9ce5a19a36f67cc1390bf74f", + "SOURCE-PIN.json": "66faac1fd4e79bb6d9fc774fd8ba63522ad3309456be1c81405794b284c55c83", + "SPEC.json": "81676590c26018aa95082e3252f394ac99c61c0c4e5578f59501401700e38033", + "audit_fast.py": "26950da76589b13cd9c452fdee1b0c354806977f881299bd94073f00e4646fcd", + "audit_mixed.py": "defdb5f1d33dd6b0eee9b84c00b5cc01e5283ec41308b520df714e1caffb9916", + "code/assemble.py": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "code/assembly_controls.py": "d7675ff0b0994b29541d37eaa3010c5f39bb1447700c9f8e750522bf8c951f56", + "code/audit_allcold.py": "fa3488b62efdf8a0c37de0ca0caba587b4b036c5f068e002eb04c71c12b9e9b4", + "code/bind_providers_portable.py": "1d39bcc7b63ac158e021454beaae897d123e174360573762aecade3cd43193f6", + "code/bit_supplier_controls.py": "e6d33fb61a570c3f50669412acc467a3fd06ef0b806da6a75bc296c6ba2142a5", + "code/emit_allcold.py": "549603ca6d28b163a43b2dfaaaa788161c73d7952ab9190289407caca5418c71", + "code/exact_coarse.py": "5fd03ee160a8bb02a00927cb144359fbcf8b0ec323ae0662778dd1f655b4a216", + "code/fine_cache.py": "89282a83ab102893a4fc1e663ad2137d891d81e843b1c9ea140d13e58b7c7dbd", + "code/fine_mercator.py": "6cf29658b5c1618de4aae8bd49d6d890be06d57ead1ad0f2d41bc8d25cc578d3", + "code/fine_moment.py": "bdfc492be6a663b219d76beff444db14bd67bb53c7c8ec4086ab0f56e48323c0", + "code/freeze_spec.py": "e9132a9d195c66123f2747a17f7ef404b4d1e3ef6263ab4c28c983a052cf10bd", + "code/generated_identity.py": "c8af22719c0f3097a991a3f6ccac8f090afd2faba554745733d9ea88f2c25708", + "code/invoice_allcold.py": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "code/lemmag_checks.py": "cc753c5953e58f5900ce580ece8f814a352d672bcee6d4566c7dd52647912393", + "code/lemmag_stage.py": "5158e1e95e46b3119de9f4add7d849c8ad2d2dd92b17a79b0f93b86e7d4e6049", + "code/oracle_check.py": "4836046db4bec939515a5a272559f92192b56612b98f635910fd81ea754ce2e1", + "code/prepare_global.py": "8c0dae301a8f34b77a5a462f840952d08ed120576212adf5051bc09bcad874dc", + "code/restore_parent.py": "69b7b25ff85e9b8160e233c1d415cc6a0272019e5c486dcec14cb6c349e7024d", + "code/witness.py": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "construction/leaver/PIVOT-SWAP-k8.json": "3ef7acf0cf67442a532f25b53d5fbeda76d3a84524118df8e003ca69b5cac0bb", + "evidence/ADMISSION-CONTROLS.json": "5cdefeff2516a67c4dd60e609019b3e2e38eb3d43142df2d3c7ed9a6822d5050", + "evidence/ASSEMBLY.json": "5d9eb1ce551386024b5b6894836f81ed03a83d2e0c0bd0e02e3f6410a596bb2c", + "evidence/BIT-CONTROLS.json": "d74d9d2ba363c3709e9a3b33abf6d14abd6b9c68d950b35b7669d8e6edefa59e", + "evidence/FULL-ADMISSION.json": "cda48de718d060b8ca329f1254f4f999a5a5bade5cecabb265f0a9bef1135089", + "evidence/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/INDEPENDENT.json": "7150546e840e859268c40c11c2c79ba4fd646fc632fced68e3c19355b292fa61", + "evidence/OUTER-DISCOVERY.json": "413ef3e9eb1c3ff680cff1e600dc7160afda228e0b6b021c1a4e4a37ee486cc1", + "evidence/REGRESSION37-CONTROLS.json": "0196ae228d583f2bac3c42d3576a8d378fe622592e377c4c1921b5ae81351854", + "evidence/pr1377/CLAIM.json": "cd089b08077e0151b9ed917a5c33aa7aa6b0de790bd9567442531b48729da8d3", + "evidence/pr1377/PROOF-NOTE.md": "dafd8286b1c9224ed6f50bf71bc34b77918323b936ea7427a4b71c3b644b2264", + "evidence/pr1377/RELEASE.json": "a4fa2ca0f79a11dcdc3227ad16a408d4d22d83b7401c894cb0e31eb2c9c5f7df", + "evidence/pr1377/RESULT.json": "1cdadc74fef4cddeb2bae5e32fff7bc27456740150440ae8fda8822f569c2492", + "freeze_spec.py": "1d965b7a329b98008fcc67e73d03dcf6e75f0f33c2858a39f1182bb3d0ed0ea1", + "geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "independent_core.py": "c4bcd06a6f761e8b298f23ff3da81053cf47a7126fa1322f732a685cdb58b517", + "inputs/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "inputs/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "inputs/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "lift_parent.py": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "new/BORROW-PROVIDERS.json": "392dd6da6e6da7ceadab046e7b6ad656f46ea5693e7ebc3291707d74fde99c87", + "new/CHAIN.json": "f18804a71bef7005e892b0b7baac818d5362fff685fe5b5aadfe8de6e442446d", + "new/EDITS-1.json": "dffa640c04d71111d3e4bdd7f5a991450ba07049a1d434edeef84791c0cc2d05", + "new/EDITS.json": "d5f9a0444dddcccd35c0217f60dbd6863486241629a747c3bbe4140b3d55eea1", + "new/PLAN.json": "a31260c7718bda6c0ed55ea1a4ee6873dfcdfef9bec033c5f0416c5e704bf292", + "new/PROFILE.json": "4b002d61fc50861df1c85e517b0466a063ad9a85464cec247a99ab5c92bbf38f", + "new/SPEC.json": "7485e560bd810d6eac962b16295f730545a0341dd2ab1f072a0682c376fa1ff9", + "new/borrow-fill/DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "new/borrow-fill/FILL.json.gz": "8f324b0e4e57f2089d805b34dd10e814e868211a018cf8ebb8538ba9c40778d7", + "new/borrow-fill/ORDER.json": "e48b51a7d6a315971fff8b8e51748251750ff4ed8fe30b8b023de1a1a8019783", + "new/borrow-fill/search/agg.py": "267a66287336b72731b897508073dae1a7c85fa72cd86093a7340ddfc12af04c", + "new/borrow-fill/search/base74.py": "acc99c57730fe50f88538e4061e7165a7f278ed7499728c24b0522d479be8b8c", + "new/borrow-fill/search/ceil74.py": "99df541abe458fb6154755d9c67066b2ba0430b06f879a7b5a43e30618f4c1d7", + "new/borrow-fill/search/evac.py": "7c6ce4e8aa9833a9d451c5d4b891bbd1927315bcbf112d3c15845f0ede2d9dc3", + "new/borrow-fill/search/fillbase.py": "4fc6fa920d8703ccec860bee0e1187a0a8b1e37b245789256f7a4d01ae8a2b00", + "new/borrow-fill/search/inv.py": "eec279ea8e8d9d1dccc2733a88129351678c73fb51f06a4604a9c1da1d771387", + "new/borrow-fill/search/lattice.py": "8f2ee194fa4992d1f45394b09b5151ec699b28e4c950b9d40b826f33cbb635ba", + "new/borrow-fill/search/lnstime.py": "3a1ff558f10b0b935389137627359f875ca484717ffa3ced7de8d8b588836755", + "new/borrow/alias1_controls.py": "f4cc82312af891ea48956d9953a061196a8c3b113ef6d81e5848fe95745147b2", + "new/borrow/alias_build.py": "40b97536c8347733eaae24a3c4a13f5d21711e983106454777837be487959f1b", + "new/borrow/alias_enumerate.py": "7324f2569e6b76981d8c964a16ff9a3bc9e770e41b9cc6ec1c9defe8e662c153", + "new/borrow/audit_local.diff": "202f6f2032552eba069b9ec7e33b729d4af2ffc20974a9e82e444d906d7137b4", + "new/borrow/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "new/borrow/borrow_controls.py": "07fbbf8e2f06df063dc9d88e5e4f721222a9fcf30b983bf9127cd5aa4b611627", + "new/borrow/build_word.py": "40047409dd9f9c406bb37a2ed0b4c8159797e0e4a114d525a368355418128707", + "new/borrow/emit_word.py": "a057ed0c81fbb07dabf38247e0ce0cec6c5fbfa31d8bf1b38838bd3758e41f87", + "new/borrow/guard_cut_centres.py": "5df204597697756808e6c959f5bba81cf35a2f0e7a0f1f75748dca1814373b72", + "new/borrow/guard_helper_indices.py": "d93aeb2d51d77ca93ecbf9e566d9000bb436c279e2a25b699a867e9697f782fd", + "new/borrow/inputs/alias1_43base.json": "3b7bb0fea555d65a3b53c408ad3caab1d322b0a1635bdd14cfb45cf76693a345", + "new/borrow/inputs/alias1_43extra.json": "42e509a4ffa5c55d8bb1541bb483f3b6e81e04e2fc6df0cfb85796f9dc9e58e1", + "new/borrow/inputs/alias8_43base.json": "8210fbaa107744fe09fa02d3abdd5982b68a8af4710d4c3c3d604f8ade18f8e4", + "new/borrow/inputs/alias8_43extra.json": "e5fcc94a2511d73749f9cd1b4e4eaec0602bebf85b8c58144bebc9c4206b30f6", + "new/borrow/inputs/blocks.json": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f", + "new/borrow/inputs/entrance_43base.json": "1b3c09f9558c50e7f299aa10fb21dcbd1b5ff397794838d8629c80d4c7a565f5", + "new/borrow/inputs/entrance_43extra.json": "e57ec67fa0a3fca63bf9e4bb9edf4e6be48db0bd7c9e092cddad29b26b897463", + "new/borrow/inputs/extra.canonical.json.gz": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015", + "new/borrow/inputs/gauge44.canonical.json.gz": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91", + "new/borrow/inputs/handoff_43base.json": "5ae3062bcce666c8c3a3a650e345adf15c22a2800fa0e17d79ad6e8b97208a2f", + "new/borrow/inputs/handoff_43extra.json": "4238a7c5093a4347fe69adf4f76e507d2f43c4e727d91b2c4705039e1cbaa06a", + "new/borrow/inputs/kernel_43base.json": "7f06b4b08a49192a27e8f4132ad0c93521dad90f97ca985a173944ba02c5442b", + "new/borrow/inputs/kernel_43extra.json": "ef95eae03915f0222bcd486959c6dfe307a9a0a856702420fa35491abfae4c84", + "new/borrow/inputs/lowfour_43base.json": "a8df0a2acf85e96febb35d24ae047c370d179095b46142bae968f06348bf1c18", + "new/borrow/inputs/lowfour_43extra.json": "9dbfb49fb3c04a0652dcae9a962d973489679f5d1ee2baf4e65c58d2e8ef578c", + "new/borrow/inputs/prelife_43base.json": "0c901b689b4d12c1f50a61ec5b99e6cc38f1bbd524f036203e5a250d44c0f21a", + "new/borrow/inputs/prelife_43extra.json": "ae67d2bc3873a3f08d7cb46bfbd4e4d54f9e7f471b695b28f69907c6b18a69b3", + "new/borrow/inputs/refit563_43base.json": "0662e4800279890f565c0ee5668ed97e8ea25d6ea4a8697b4c1d9a4715716cc7", + "new/borrow/inputs/refit563_43extra.json": "0662e4800279890f565c0ee5668ed97e8ea25d6ea4a8697b4c1d9a4715716cc7", + "new/borrow/inputs/refit_43base.json": "19a97e80b0ee3146e0244e6bc36bd365d89e9c1cd0f885c4e06be4193606a323", + "new/borrow/inputs/refit_43extra.json": "1349d54f704847fdcd4a00e323cdc9e1118fac7fedb0c7573e9b2b3f0169a7eb", + "new/borrow/inputs/witness_43_base.json": "65ee52604e2e49a30c1e978b7ce829482a694a20a8744f37b9bf40dad1ff3a2e", + "new/borrow/inputs/witness_43_extra.json": "19c652db80d5215c958c63b5d6f2de96d9cf34a0e4d56dab5c13e556c57f7467", + "new/borrow/lowfour_controls.py": "cc2d102a3cf1cc1063ea39ab7b22c4231445dfd485705661b1da38bcc6da8066", + "new/borrow/prelife/results/gap-base.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/gap-extra.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/prelo-base.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/prelo-extra.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/tryE-base.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/results/tryE-extra.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/search/chains.py": "588d6cdb2312febfee5f3d576295f2edff53ca74c14d21ed9bffed3312dfa32c", + "new/borrow/prelife/search/edit.py": "8e5eea35d0bb83aa60bd066ae9ddf3f4b0ad46cf9ac9d31d8fc5777f49013713", + "new/borrow/prelife/search/fm.py": "36174e2b7e012726964282af926fdf541332556bcc548af5b41502cdb8b198e2", + "new/borrow/prelife/search/gapbound.py": "a0fa0fbd079a456bf5f9b75352eb68c4b7e2febad0c99e66b7553bdc744772c8", + "new/borrow/prelife/search/mk1.py": "4bab66a4e1514a067572c7854731a4fbd29681300e95a4384fdb68e0eb140575", + "new/borrow/prelife/search/prelife2.py": "db1fc5eea7bd70066188d7c7f52cf4be8991e61b821d3fe4b779ee30c7f3c9eb", + "new/borrow/prelife/search/prelo.py": "157dc45b5fcc421d26507d6d7fca6d4caeff6c73efcd679fd28e906f600ea886", + "new/borrow/prelife/search/propbound.py": "735cd4d1a6a43c96f397eb5ae2972e86ab71c2c232e6d14ac6cbf1eb7f638c1c", + "new/borrow/prelife/search/repair2.py": "410ddd6f9b3e14be6b9247cc5792d1a893175e843a0c21bf667e71a6e3a9710f", + "new/borrow/prelife/search/tryE.py": "130a859c0ad20623943b25800dd2f1d0355cf03b8520fc493ec870baa010b2ae", + "new/borrow/prelife/search/wordmodel.py": "215e678d3f3711b4291f9da5d7937cdbb0b091390bba089e6949b8c42a29f6f4", + "new/borrow/prelife_controls.py": "c24398bdc407aaf6713201100d27ba851233525a9dfd747b641d99e1cde66cba", + "new/borrow/receipts/AUDIT-43base-pinned.json": "8dc6daa8929c1137c1e37fa5a1bf869afafe94c3e65ed2705ea9f41f2dc8cee8", + "new/borrow/receipts/AUDIT-43base-prekernel.json": "fb6f40a1d117bd304cc0757ac21915bd8558e8d3f31b8709129f395033fc534e", + "new/borrow/receipts/AUDIT-43base.json": "07b8a4836fe2659d0d46957ed0973ba3334f6752b5c1235d03b961a107fb95d5", + "new/borrow/receipts/AUDIT-43extra-pinned.json": "4176a6190fb1a224d45797064cde2aa758970bce7c1ed2a009ecb2fc7839d26e", + "new/borrow/receipts/AUDIT-43extra-prekernel.json": "09041e49888a1360b7ddee29d54d82836a875ecb6547c7ad1eb92427e7f3b384", + "new/borrow/receipts/AUDIT-43extra.json": "a01ae6847449ddb88c56fa8e44d10bc0b005f1b24daa283d38ba00089d8f89f2", + "new/borrow/receipts/CONTROLS-43base.json": "02b73bfbf72c63926ebb244bbd6bf87a03201ee1487e2c15292ad52684fb4d69", + "new/borrow/receipts/CONTROLS-43extra.json": "f8b93901ef5b4810bb39a7b5ccdc62497612c2efba67920a8d6119ae8a898126", + "new/borrow/receipts/CONTROLS-KERNEL-43base.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-KERNEL-43extra.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-LOWFOUR-43base.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/receipts/CONTROLS-LOWFOUR-43extra.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/refit/results/pairs-base.json": "8178d2a34be82601f2361afbc63b37294255a435b243e65295bf7b641edfc4a3", + "new/borrow/refit/results/pairs-extra.json": "3a64b6ace504a5d410a4cfd87ae2fc04576df61883ce56e3f7eb38d4b26df8af", + "new/borrow/refit/search/bounds.py": "690986e69e3125723b12255cc5aa135fceec93894d589eb196ab7fa5da37e9fb", + "new/borrow/refit/search/eval1.py": "0547e606468ad4670512ea83fb3d6e7f39fda9b66537fdf791ad22a3bf4aeeee", + "new/borrow/refit/search/mkcand.py": "c5b437f6a991de674bd781d610d98a43d9f84179beb1187340354e55f42ceaa4", + "new/borrow/refit/search/pairs.py": "7922404bf942eff2dda0125b78ff1234bfdfda5101ff428b11f8a5ed73ce4882", + "new/borrow/refit/search/refit.py": "c036d0d4cc91360e583a7ed01d6c69c17a69f16c5838062c2b9de83a616d2e23", + "new/borrow/refit/search/why.py": "209a95a62a95c06138f0b5af2d1dd1f9c60c403c4da294d39663928c2312425e", + "new/borrow/word_patch.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "new/borrow/words/BORROW-WORD-43base.json.gz": "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc", + "new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "new/code/borrow/bw_audit_local.py": "6bc8a07942a027a52ede46521f6b5dab755643eb693efc7dcb829496050fde09", + "new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "new/extra-word-566.json.gz": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62", + "new/gauge44-word-566.json.gz": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "new/pivotcheck.py": "6eb1752f077df108c908974413fc71abc751356b07c6e650e75d2075f1a51391", + "new/rebind.py": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "new/rebuild.py": "7391a7228d6b5afc2f88afd5d5a987565d78a100386c1f03b8696bcde2e8ef3e", + "new/rebuild_borrow.py": "9cef11a627dc197d68845efec25ec22c9af69a132978d8db13f6cfc0d1841b30", + "new/rebuild_chain.py": "3a5739f94f0fea1aa267e7d12e1c986210e483c841a8855e11020128a017510f", + "new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "new/steps/0/extra.json.gz": "17cc6c177c89eb264514e1efb3685ab9a621f3952a8f393a6a5eb28cf77e2884", + "new/steps/0/gauge44.json.gz": "0740b6f33927b9e60c9a7f35e7fcb2fd9ac6e2d3982112428b302a6966a18c73", + "new/unpin_spec.py": "03901dbb881fa608b6540a0541b26311dd4bab23bd8768e9ed48b8b355e1b36b", + "outer/B.json": "2a6ed1fe7f601146af00ddcde61776a9db8d787d3e43c13f4c0436b529a4180e", + "outer/CLASSICAL-BOUNDARY.md": "6647d5a71d9f6c3f628ac71a7be2e63bcb0cac9618cd4fee7493dcc4ef02529a", + "outer/FINE-PADDING-COMPOSITION.md": "d20d8e5f84a9e33cc9996f875be06c24c74ea53874cc76564953785ff29c5c6c", + "outer/GAUGEFREE-INTERIORS.md": "a3f67d945eada51cc93c69438b1fa3173dd6dd0f7bb4e76cbf5116fcc496edd9", + "outer/INDEPENDENT.json": "dd27ba85431ba0b4297ab906166adb4ad5ca5883af1ec9173e056cf3d5231b21", + "outer/LEDGER.json": "31d72437d30aa6a8b8a327700196f0ce6e7b327d37239578fd5d9248f6888e9b", + "outer/OUTER-CLAIM.json": "df0d5121f0955f2c9743621e3a259c4a34d9177aa818cf5a21dc1edd849fad64", + "outer/PROOF-GRID-MAX.md": "19dc50ad398993d156f9366fc752321a88a7337dc016c00b0d5a53eceff93cf6", + "outer/RECT-BOUNDARY.md": "17ece1cc1eb4a02df4d8433e3612231768633e6674d315acbcf880f36e30bdc7", + "outer/RETUNED-SLACKS.md": "d87beb3869fb60143c2c3872d7c427ee16174aa51b5e6f42689312fbd40d3d42", + "outer/STRUCTURED-BOUNDARY.md": "ceef915be6462a8ad81449eefb86bf4d97db6ac41c87660e9dd7cfd2c2bc1efa", + "outer/UNION-SCHEDULE.md": "bc8e9cf7c178bb39b092ab5aafc4eeb523e72b1f69639bfcb9f27d0f74109357", + "outer/check_fine_padding.py": "a0ae691251cc50ba20b7f23f89fffaed802d62f9192a441131476914a5bdfae8", + "outer/check_gaugefree.py": "2957d2aafc56e3b757c5734bb29c3258cdf0ab167bd06ee0daf95281b5207e10", + "outer/check_ledger.py": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "outer/independent_check.py": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "outer/replay_evidence.py": "d3bdcfc8ce29865b3a76d64d99b5177e73fe994a2eb915f35fa233c5ab81df65", + "outer/run_outer.py": "9d5dc0a7ea38973ce52a1cda02d311c235bc7c39c4d20921d5811cab1a57ef8c", + "outer/sched_review.py": "f440a57f1f46119ee8c2934c8f0d618ca1c85c73cda8cfb8453c2aa1b9fc40fb", + "outer/sched_test.py": "f96d09b5990931e3df8cea291520bf17c424215748cd9ec068214c58309a21c8", + "outer/struct_check.py": "f1df92bb6247034a22e141dcb39c1e8b6b9df6eb9791493be25a3911f7add8d4", + "reconstruct.py": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "replay.py": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "requirements.txt": "255a2ee4a60637759d4d5c89448c55849153e81ec1d1383555c6697784d9dc97", + "vendor/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/CLAIM.json": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "vendor/pr1297/COMPOSITION.json": "6fb74e73fd298b356402eb2fbcd625463b2fa540a6be4ef2d6335ddfa31d70f6", + "vendor/pr1297/CONSTRUCTION.json": "fb5f74f59c89b93c63ec47e32e2c9264658e115d1f21eed3eceefec7dc7a0cde", + "vendor/pr1297/CONTROL-SITES-base.json": "b41361f5a2f6ab3d223c146269c8027a0537f1a6e3c963f28cf1ebbe05c5d7e2", + "vendor/pr1297/CONTROL-SITES-extra.json": "f1aada769389ec410b41bc9e2082826bb916b8332c915ee9e07045135c30393b", + "vendor/pr1297/DEPENDENCIES.json": "9c9fff3ac059da4d4e2f13e655afb9e42ada1a57987f5b47b68dda4b64797966", + "vendor/pr1297/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "vendor/pr1297/EXACT-RELATIONS.json": "6864f378d917d0ecfd8cd53cc26303217ebb48f47f2987bbc01cf1e2c9a28093", + "vendor/pr1297/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "vendor/pr1297/INDEPENDENT-DERIVATION.patch": "6b3af098ec1c9e2360a366933eb7fbf0e16ebb37d43809d26b275e66fb5ee779", + "vendor/pr1297/KERNEL-CONTROLS-base.json": "cbe755333f469a1f01258b65f2b273763212dba6642edabfb58f7490f326abda", + "vendor/pr1297/KERNEL-CONTROLS-extra.json": "cf255deb866ecaefca4b6ecb72f105d6b08dc8ea907a8381d45aedc39b2022cf", + "vendor/pr1297/MANIFEST.json": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "vendor/pr1297/MAPPED-RECIPE.json": "09aca649da97a37116262827cbd3ebe0addcd2b1a33c08e8347f3daf3394176a", + "vendor/pr1297/NATIVE-VALIDATION.json": "755b7087e0ae964c538e9378311e07dba2867c16b568d1bf6ae9051657f9f5cb", + "vendor/pr1297/NOTICE": "b352129a07fc8693f57c77cbb0ea92230b2fa77439f86c9f35b828213f9c42db", + "vendor/pr1297/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "vendor/pr1297/PRICE.json": "e19f9f9e70e4fda2bc4a39fae93ea44555945cdaea59728864c5a44dcc5522e6", + "vendor/pr1297/PROFILE.json": "d9bbe0d73ba005749615915a2d884819a6b141e3402d9e7f87f4592a2d27af99", + "vendor/pr1297/README.md": "102ac7f080c1799aaedd5345ffb3631845215e8ab770e2af34750c25f667686d", + "vendor/pr1297/RECIPE-base.json.gz": "0f2db2c658e9732fdd1aeb7bbbb5c786d6045de8a2575b7654b9e6fddc71b03d", + "vendor/pr1297/RECIPE-extra.json.gz": "9e6f58570b0a8f9e8271bfbc73a339fce42f1cf28bf14d4db93f246b8f63a3c9", + "vendor/pr1297/SEARCH-RESULT.json": "7cdacadcbbf83b81f9f91668fcc707f8a238c6025f35a8bdc36758619c2591c4", + "vendor/pr1297/SOURCE-PIN.json": "e93f303f4de383757e50d612ada5e379533d46737a32281aa6879fb4b6138e09", + "vendor/pr1297/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "vendor/pr1297/UPSTREAM-NOTICE.md": "b97fb4731e84aef736c58a9c126334eb5b8d3a057a8d9d45b4ffff24af65c38b", + "vendor/pr1297/VALIDATION.json": "1008f637a22f954ee774920a8362931ca7cfed63ca146e725768c0f39803c0a5", + "vendor/pr1297/audit_mixed.py": "7466461cc15cbb12135d94f2d904d4e90e78cbf4755d0293ab9bd55e3568d4b0", + "vendor/pr1297/build_word.py": "ff08af2851b4813c113ef63113566cbd79625e9310611292913d51be554b5aa9", + "vendor/pr1297/construct.py": "71aff454291d4a35068c43dbb65c00ff511f48e91ab7cdada462833f04ac73e3", + "vendor/pr1297/controls.py": "935cf39ed6601eb6ac411b7b1a4adf5d4238589cad9fd5969d7dca967ace4c4b", + "vendor/pr1297/extra-word.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "vendor/pr1297/freeze_spec.py": "0f5c8ad43180a633a2cbbd11f7832729039402c68f593679552c43a1693d69fa", + "vendor/pr1297/gauge44-word.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "vendor/pr1297/independent_core.py": "d1dcd5593a05cf647b485db38891984f829abea5f95c6cc91e37d554bf163d48", + "vendor/pr1297/inputs/base.json.gz": "b87c706d14a7e1972514ee901002a930908073811ef38761def31c8e36351916", + "vendor/pr1297/inputs/extra.json.gz": "ded6903e00deb9e158fa700b03ccc9b8bfaae6c8bad8ca4842f0ad9b963234ab", + "vendor/pr1297/kernel543_controls.py": "ac16d605e773197e3664643d40b36c15a7130a45e95e36bfe7b42d939644367c", + "vendor/pr1297/kernel_controls.py": "436e3f3d9974da7c1968ef99fdde5ad203a61544d8195493e3150eb25869f4dc", + "vendor/pr1297/original-main/research/complex-t21-owners/vendor/pr870/t16/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/premise/inputs/CODED-CELLS-k8.json": "7347f814850a838bd617bc7a55c307cec2b72becde2f12ea3e2e1af344b43563", + "vendor/pr1297/premise/inputs/TRI-LEAVER-k8.json": "b22e6ecf76104de66844bd617c4ca80f5546ba0966a50e5e9aa0ffea4976cb30", + "vendor/pr1297/premise/premise_check.py": "28a7f881a988b29b8ed3c927dd142ac3d4ee273dedab3a65bb02c01a64eb2639", + "vendor/pr1297/premise/verify_1049.py": "a1736324c6db161733d8e11f608defd87b7f97cacd611203d22499e4c7de5545", + "vendor/pr1297/replay.py": "d3ea7c2e74ff6df9d14969f994eaa85f825372cee92dafb77bec4767edb242e7", + "vendor/pr1297/search_relations.py": "58f3bd092cb8592a070d7879918ff318a658a6fa02bfad7b5b8f4cb0fe16691c", + "vendor/pr1297/upstream-layout.tar.gz": "a0cc229bb0fc9ab8ee5c14d5de87b3de31d1fcb793e99192c9cdc63781e794a0", + "vendor/pr1297/vendor/pr1193/CLAIM.json": "b9db2fbfb004b505ad535e4763915275dc5908feaefef32e65863fa65de061ff", + "vendor/pr1297/vendor/pr1193/DEPENDENCY-PINS.json": "c9330aa6a4226c804060499429cb450820d7142ab17696eb47408b04b410b5bc", + "vendor/pr1297/vendor/pr1193/MANIFEST.json": "4837d070679d9e70218c7cfa2d3e70d7d742a5b74dc66d224840b1a3a4ac4a31", + "vendor/pr1297/vendor/pr1193/NOTICE.md": "c7a17a0a35dc249f8ebcc550b3791e214aa65872eab8a6458c5167dd7b948e5b", + "vendor/pr1297/vendor/pr1193/PROOF.md": "b2a38120ddb75e90764d0b81913d60b46cddac4d943cb731bd9c7134f1c236d1", + "vendor/pr1297/vendor/pr1193/README.md": "cdcf62624912150ce4e6e05356c27299251eef4cfc130e4f209839cdabc05e08", + "vendor/pr1297/vendor/pr1193/SOURCE-PINS.json": "08eed0d6822a1c17053161929591e7ac36b9f91f8fd61190183a6d975948db85", + "vendor/pr1297/vendor/pr1193/audit.py": "1118d483b6abbe7036390c0a1053bcfec2038dbac273fd1bac92a68f38e6d7da", + "vendor/pr1297/vendor/pr1193/build_word.py": "effb72aecfff9958fe078ee89e0d37b85d601eddb19fec4520d7ee6e936edfae", + "vendor/pr1297/vendor/pr1193/common.py": "274274df31f8ef2a47b801d1f30ec226f94bce674fe15586d814ca754f6b7785", + "vendor/pr1297/vendor/pr1193/construct.py": "3dd333b50f4bd1d86956a6df4a334ed746d75d0a9e03dfadbb6724b4356e0cd6", + "vendor/pr1297/vendor/pr1193/controller.py": "d93ed519a0f2316b87b66f44c5ea615f0768a263dbd800815b536d8b7c86b8b7", + "vendor/pr1297/vendor/pr1193/controls.py": "574c55a01cfc34f5b9688cdec5646160cf22b403decee36d18b11f1b07e71f21", + "vendor/pr1297/vendor/pr1193/data/FLOW.json.gz": "e8e6dfa66e083ff8f3617a8441b5b2d766c3c9d9ac62ddc37d99edc24051f79e", + "vendor/pr1297/vendor/pr1193/data/FOUR-RECIPE.json": "384b32c5b0e9b3baa1c7232db884809596d30fc55553094245f7b739b1a43484", + "vendor/pr1297/vendor/pr1193/data/FOUR-WORD.json.gz": "7d09ee1b8b9881313e5fb1f623c0961d59b0c6352a019bc9164a6cad8c58e27f", + "vendor/pr1297/vendor/pr1193/data/MIX.json": "dd86bbb792a5c9f0d7507d55bd2f8392c66716023934b03b24f48ca737204eea", + "vendor/pr1297/vendor/pr1193/data/ORDER.json": "7757df3b54ca5e84c6dba9563b10bc6215c5e289313392b5a4b493179a245c29", + "vendor/pr1297/vendor/pr1193/data/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/vendor/pr1193/data/PLAN.json.gz": "1f1085beb84b516b9a96ceaedc6c3de1c58941fd00b6e70f0d0c686b6546ff79", + "vendor/pr1297/vendor/pr1193/data/SPEC.json": "82b263990afdc5efdc1dfe38ae16d7815004dff8d70f85c28fd8286c31f688bb", + "vendor/pr1297/vendor/pr1193/evidence/ANCESTRY.json": "cd880b2d1c2fb8d9050458bd13f228385c417a95e4d1985607d9f4bb60b5c109", + "vendor/pr1297/vendor/pr1193/evidence/ENTRANCE-CONTROLS.json": "7b101dd97c1025667fb3615930a9d6cd2ec443169d263a3bc1191b80fc712a1f", + "vendor/pr1297/vendor/pr1193/evidence/FLOW-CONTROLS.json": "43fe7e94bd72607d502ed947ac1463405be18728eb0b8faabd7ba63ab1d28ab4", + "vendor/pr1297/vendor/pr1193/evidence/INDEPENDENT-OWNERS.json": "4c295ff53f51631e1720b0dc2ea895c34861435fa92112ee52439e4569de968a", + "vendor/pr1297/vendor/pr1193/evidence/PARENT-CHECK.json": "2b729fd666ffe4e34a355223b57f74ba460fb171b19c84f260378dd109f0b9a0", + "vendor/pr1297/vendor/pr1193/evidence/PRICE.json": "a1dac219b019f8d40d5b434b0e0c25b0d1f097fe5ae13eae45c76869aec4758b", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote3.json": "02150d4cb1b2f4763b5c5c20ce979c740cbdfc1066e021a8aa5d407de5c4b9d3", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote4.json": "7adf0070125b2c61e04d46c5f1cbf57af079eb733799bbfcc3fe9b0551d964b1", + "vendor/pr1297/vendor/pr1193/evidence/REPLAY-SOURCE.json": "a5a290aa8c75fffa45c9ad2e3441d5051d3adaf7934f4d0311875fb4d8f023cf", + "vendor/pr1297/vendor/pr1193/evidence/RESULT.json": "62aca8286cbb021d2535d81494f7ba7a3aec20898fd7c40a895a461bbd303ac4", + "vendor/pr1297/vendor/pr1193/evidence/STAGES.json": "0dce559b2a8f371f369a05ae25ca5dd6a48019b5685b0097f001a23bd849429d", + "vendor/pr1297/vendor/pr1193/evidence/WORD-RECIPE.json": "b6750c8123c205b63786fb825da26a819592f71736a82009809ae1cf96173a5c", + "vendor/pr1297/vendor/pr1193/local_controls.py": "fe3d13491fa7523eedb8d24577ffe4bbd6c36a87b4a7d1178e5795d223bed4b8", + "vendor/pr1297/vendor/pr1193/native.py": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "vendor/pr1297/vendor/pr1193/package.py": "cde0b2d66125649ee84440fc0a67f0d91f900fc838fbda069b579422289ea3be", + "vendor/pr1297/vendor/pr1193/prepare.py": "9fe454a5f857ff73c70a5b276bc9e289422b051a4cbbbb51123a91bb2200e6d8", + "vendor/pr1297/vendor/pr1193/price.py": "d45042f4c1fea352349377b43def363cf75a742546a1d5c790ad30da91791803", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/JOINT-WORD.json.gz": "a0622d86259c4163e58cf0677ce575b6039a8ae4c95aa6d8b82a8163cbd42718", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/NOTICE.md": "afbd38d6c8a232ea566c296424a86420f204e6cfaac565c0a147340bda3d3da6", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/PLAN.json.gz": "e963ed64b9970858902b9388bcf1c5f9cc704859ad021ce8bda465a4dcef8310", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/SPEC.json": "55bdb68d5d126c6be0e0acc419bd62301a978afd514f9834ed1e08b1aa4f563e", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-coordinated-owners-NOTICE.md": "442756fc1c5ecfd7b7b7694b53b1ecc70aa525004cd80f7d748ccd7270555189", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-NOTICE.md": "820fa13161f857c221f2c4099dd2985c7ff72249dc7a0221bc00fd0c1b9760e5", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-t16-NOTICE.md": "a9e85b59dde61fbff0b006923b441cbd1419e24fa9802426785bca667437fdc0", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-three-demotions-NOTICE.md": "a0fe85fb2207f0e6831a96deaeefb65afa379c1377a29f0b586f1db4bb4b2137", + "vendor/pr1297/vendor/pr1193/verify.py": "e5c952989344a65b7e63fa112dda4d464979814205644a8ec34e407a0d96be29", + "vendor/pr1297/verify.py": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "vendor/pr1297/x54_controls.py": "82f91b81be9173dca546345dbdaddfc71e6d21e626fb84a8b4d1b4ba0d673814", + "vendor/pr1673/capped-phase-fusion/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/FINAL-PACKAGE-REVIEW.json": "3457385de52d8e86853d96026a70aef2e8dece516db9eea020d8774e01d076a8", + "vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/INDEPENDENT-FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/MANIFEST-UPDATE.json": "32c58bcab8e19ef895660331c13d31b5fae7d0c95f7cda4147870f29d8299f6d", + "vendor/pr1673/capped-phase-fusion/MANIFEST.json": "9af581d640e9c69d513256cf69babb0717287642134cfc807cedcd79966c1706", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/MATRIX-TRANSFER-MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/NATIVE-RECEIPT-CAPSULE.json": "a04d6bba3d15c11a219536b66a23012797484ae106ec1952ecd7b76f077ddb01", + "vendor/pr1673/capped-phase-fusion/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/PACKAGE-MANIFEST.json": "298f1eaf79b5d5d57cb96fb3abb422174b78c31c14491a878f6176431d731d04", + "vendor/pr1673/capped-phase-fusion/PHASE-LAYOUT-AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-CHECKS.json": "6e2fb68e6768c3aa4224aacb4900263586fc8114815a51df40f3f9fdf6124217", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-SOURCES.json": "6082583794168b1c2320187214b86c93a5a6e76fbbddfcb3bdbb8c5bd34c0586", + "vendor/pr1673/capped-phase-fusion/README.md": "91af88b8fc53a22e1e968908f0e449cdfe2154c83f0dddb8a504e661c0c6965c", + "vendor/pr1673/capped-phase-fusion/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/ROOT-EXACT-REPLAY.json": "d36114abe9d7a83c327f49f5ea153c6dcada4a7421f5e74a9a5ceb392cecb994", + "vendor/pr1673/capped-phase-fusion/ROOT-MATRIX-EXACT-REPLAY.json": "d6bd4fcb8a528655181b4aa3fd1bad7e6647a4ca5aa76ee7f2cdd800b698b225", + "vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/SOURCES.json": "14ce6fdc7c83e18ccf4fee19ff51062726c960ca44462a45af60dd686167d456", + "vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/TASK.json": "47b82ef23e20991010fae838ad4da9bdac3f947a8fea916a028fd6260f95f5f8", + "vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/VERIFIER-NEGATIVE-CONTROLS.json": "eeb887cdc0c76426c75ddbfc3d4af7ccbbe19d17962c6ad7a1549dafe8dabb5a", + "vendor/pr1673/capped-phase-fusion/VERIFY.json": "cb50aa523a0863a457181ca815e69a1b3b4d91ed1006a79263f4a8f18457c669", + "vendor/pr1673/capped-phase-fusion/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-CONTROLS.json": "eb3ba38d18bac4aceaffba39ef48dbb55bd15e6abcb68cdf66920d9d13ec00ab", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-CONTROLS.json": "ae8f0eb121a2f4da5c3f982ee6e7f45dab7b18368cadb5d2060602b0393b7120", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CYCLIC-SCAN-CONTROLS.json": "4c37249f12b4cb4df847d179df8f378fbf1f42917e9fa703b2d847146f29b95c", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/DYADIC-INTERIOR-CONTROLS.json": "afbaee9f56f6a66fd9421bba7dfa8c3610c12bd447b01d0e9d79f97d1216aa90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-CELL-CONTROLS.json": "4417a518ba3b6833f06b4f5e33d4f73ea74100b9110cf20e8d1c2070f1833fcc", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-SCHUR-CONTROLS.json": "046191420a24d8b2c063c190af5e954c85e39357902988c4df79f5abcdf1596d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-CONTROLS.json": "323cb4acae960a6fa05527df5ede9d48e274883272b8ddb5151ebcee6dd26e52", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-FACTOR.md": "dbc7eff783695e0f50fec57b0f7ca4212d51428eea04fa2ae5e0a9178fa69b30", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/README.md": "8fb5321b514af9260c44e150125205fe564efd073c456214f76bbdb358279cf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-ALGORITHM.md": "46b98b9c013dc5a94c9f17fd85acd7c1896c8e93ad2ee4a7c34f583895f1daf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-CONTROLS.json": "c9e6fd7f338f2cb78a0ed15ee944fde63549ae3d8522ab0874d184f3e252db76", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-LIFTING.md": "69535a48416a5435ea2a5ef4ecfe70fde30c32c4043bfc56f1ae2d7f49cd34bd", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-MERGE-CONTROLS.json": "c5729bdb36237c0691fba56d149019f78d94e996749532d907a84c35ef01319d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_bilateral.py": "8d5c79bd4f4c96de5c1fa91553b19e3a62419333b414fc84dec894a4b729d5e0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_capped_gauges.py": "121279bef47dd490bf29fc72ddbce547176cdaf1154af67dc8b96d7baa8cfc6f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_cyclic_scan.py": "d25156f852cb95f013e0ee74b319fc8c20d6a7a53fa851543244d5af7898ee61", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_dyadic_interiors.py": "a39617147870719a0296eef77101c90df8fbe716841cb9ed823f36b94254c3e1", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_forward_cell.py": "082a0e46c175f6e59fe1f8c168ca56bc444c71a602c9b7318c0834aae1f2de90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_log_a_schur.py": "a0f1116ce27ecbff18de7089ce1f56714ed7966dfa0105b20419d408feb7ca41", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_lower.py": "027c77d8ce33c3d5e3c436234668f11bafc3de8658b9c3d03d455eb0e4d71f95", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_data.py": "de4f9df64cf31e94adb9a5d04b38d53d823d864f51632c49c7c80c6a46b5224d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_merge.py": "95c9908134905e3ebdd030375e36a942c886cfc59edde3c6a419f36da6754780", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/EMBEDDING-CONTROLS.json": "d0182e172f16b55ec64a5edfabb10816e416348ef2db15449f3ed4b47f3fec1f", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-CONTROLS.json": "ae370f7d7421f2f96e101a4b9d8082110507c47211220fd6ead065c2366aa828", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/MANIFEST.json": "37946d7691b90d39906d93581839bdf8ae2cf899d459e5520c39e782766e9327", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/PARAMETER-CHECK.json": "e38cdfc13f1959186d888383458c9030c4bd3c8c3915aea4743d55637d2f8d76", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-CONTROLS.json": "c3688f65565486b585727374abfbe478f7544aa61381bd73cc6ffa168b4221b6", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-PERIODS.md": "c6e4dfe7f58dac7c5a513ffb3a9ab4801ab0717efae5c1e764e570335402ff25", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/README.md": "575a3acfc18a0e05ffe04a8563318a2770ce32cd7bf3a5e6123ce2de39a1cd4c", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RECTANGULAR-EMBEDDING.md": "e64447bff7e7717802ee049290faaf29e45db3e36a6f7fcec109184478f15f26", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SPARSE-SHEAR-CONTROLS.json": "d3b9763f7ef6a3a5752c6c11a8a4d5f465646ad75b178a1c1b3363540fcc4871", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_embedding.py": "597cb5304498456575c99d46a7fb503e04db28d5a7f57857b102b50f703b7464", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_halo.py": "0a3257cbb8f37b6cc9bb44019cb114ea2ae9b28738a416bff4bc712d1306e1b7", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_ragged.py": "54b761cfe3404d524af3a2abdf09bcea8dfb5cca6199c0c182cee310e3ca8c78", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_sparse_shear.py": "6e22c989e6bae92c4cd209c9336aad4359956cf370bdbd5f6b70609144598121", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/CORE-SOURCES.json": "2546f47dacc47c2d63dc5bb9cc52ef86c5e02ee159c4fb6e00dfac3f8f34d89c", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/core_review.md": "13f2df4d5b240f9b89ca0ae44bba198c935532098ff4c1161631fcbd86b3e8b1", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/gaussian_layout_review.md": "ebd7188970f55b5979b1b1a13f874a31ed0ee6c82bee329e7ad0b2a38c42c430", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/layout_subreview.md": "637e4698a9fb02978ebc4032d8939ce0db9528e89e908c94d63b9f0d2a41f64a", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/union_subreview.md": "738b35a04d6871cd73b14b4165ae69a1feb3a103eb46e064a64a22c4c7426856", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/CIRCUIT-REPLAY.json": "2ce5cf9ef9461e5897374ad389c26af66aeee85e8f514a9da4ed3bb2028cb1da", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/EXACT-ALGEBRA.json": "694898bfb1afcb3b8b8ef951634ac8919decdde0904350b355d254601ae3dc12", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/MANIFEST.json": "3b018dc660c6add775c12f75b9e8f5281825aeebc3888a508833ce6106c1229b", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/READING-COVERAGE.json": "756e52726b161eea27e27f1d519b05d4fb0ebf67ef9a67b33947194d5d02b709", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SOURCES.json": "fb3771f66771250aa9f4406ae9e7eb176f9cdef03976cbc9558440c674a4a94a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-AUDIT-SOURCES.json": "d0c274d6edd6193b09d28e45e7cbfe9236fb35474d35ea3af0664ba36f9e006a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-CAPACITY-CONTROLS.json": "6922b7d7a936d53846569ad3be53fe4f3c63d6cfe794f9279fdc6a1fe411ef0c", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER-CONTROLS.json": "db8a5c0dc2be956d83bc7667177252a4968e0ffaee8352e6a5dba5ab983d7ada", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_circuits.py": "06d1861bfe8af543908e26557ffda7e451ff176bceb9bacfaf0f04f234b336d5", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_exact_algebra.py": "5ff7f25c55b370a1d0cda6c84ab9cdf2c7b0de3266d3f2e7a43280a6491074ab", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_supplier_capacity.py": "035ed96b39414eadec46e8de4bf3811b785862fd313deb044f42e17cf2ad3f78", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_tensor_compiler.py": "dc4b1f1884489215a2c2d0e8978a241e99e6c8c9f1d2fa2460c73d2c7d4ba30a", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/check_source_constructions.py": "9d387098403c0355be8e93158df02bae5a435b2366bd28efdf0b127e470c8c1c", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/README.md": "17c393075292b364899cb7c451cebbc9b20834f9fac934ce3740aba360c27246", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_outer.py": "6a0c5f8956323615df8bc4b12996832471c0ae607d05429c9d70ad1b50568f10", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-LAYOUT-CONTROLS.json": "e6951790238b4998c632c95aa329ee2cd2527a5d74a2f28bd15249fec6d2419a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MANIFEST.json": "c98559147bb498ac78af998eed63ab6661af934fa1a0df6844176b1811753fb9", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/PARAMETERS.json": "9f72cfffa34844764ca65a6b4431cc5c779141751df746019db9d3ad8f1dee92", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/Q-EMBEDDING-CONTROLS.json": "24ead3534482397c00c23ad3dbbd4e930e02290e00c97765353d8783c6575c7d", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/README.md": "0ec721f76dfa943e808afd3c2cc39ee69f1a6e5f4f77ba3c7c1373ad60db25af", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/UNION-CONTROLS.json": "6c5262144215cc603bbc3bee93a9a6d9d2318d0177a59115fe560762998498f9", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_capped_layout.py": "267d93ab5114ec160f88a6e65fd34c9f0696a686c36ba2dd194d6b70fa32a6bd", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_q_embedding.py": "ac858a14bbaf37e0e412a7ada282cd1586632f52b8a979733e775f50130969b6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_union.py": "74608380d72567edcd4470c8d226b15848f9d3a4e5d77d652bdd8963480ab9ce", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/CONTROLS.json": "12d9207e887fda73159a9e2e4776003ca6f905fc3dc45d77ced588a1c9f80cb2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/ERASURE-ROUNDING-CONTROL.json": "cceb2ade8ce5e18be3871f771955e38258f5eb4e39790c016aab96d8cf0488ef", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-LDU-CONTROLS.json": "d6bda457fff01e04b6565d84c7bdbac870569a2ba7ef18a1fc8db11b738faf38", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-AND-Q-LDU.md": "c6a032ed495325806ddf491c5c85bc822a7fdd613aff906a7be553960d0f85a3", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-CONTROLS.json": "3f7e98ce524d5fb2ba2f911a350081340215e806ae945abf15a2fa07988ca2f8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/LEDGER.json": "87eab0eb334ddc16e50cedbcab56320d2ff056c3dc87d7a5191171bb5a4c206e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-CONTROLS.json": "b85eca6098847e7b2f77b49a6c8c35e33cf790bc5dd01b95e1334daef9af47f4", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-NORM.md": "7955383d50fc59b5c4c4d839c7e4d630add6208a3a233d7372a80309085ac6b2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/POSITIVE-TREE-CONTROLS.json": "7b31811402ddda4668fe8375f6c90a6047511d50836dbb7cfc7ffcf24fe19a11", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/Q-LDU-CONTROLS.json": "370a07aa1a56c656ec1f44d7651dfbe999ad0c19dede9036257cc2f29dc39452", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/STABLE-POSITIVE-TREE.md": "ec2f8a1c4273b81217545d2710bcffdd09b5c9ba9349e887b5f7bf6f5bddfdc7", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/SYLVESTER-CONTROLS.json": "198af9f58c2950f17d8b1861ba4566bb2f6a0108a889a56db328fe67f8faa1a2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/TASK.md": "5eef77fb23f26f5bfb5dc8e376ed25e769924f2b6420ebfc8671e3b2a2f1f611", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_constructions.py": "91387c9bd763a5c55c22a9907947bd07b6002f739aa6feedf6d3a02adea1e316", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_erasure_rounding.py": "486efd4692665a548b94b79877abb76ad13157268f05c270c4e75d8f97700795", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_fixed_a_ldu.py": "15134147317a7d789c9ea0ebd71db5ff11e59a20ef140f681d87478977734cd0", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_holes.py": "99c5dc4601ea88b553f52e235d36fba0aeb867e7fcd54130cdb3eb115a9bb0d8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_ledger.py": "254342c05949e5cefe4f507a35487e0a1ffb7137a60d2b97831d5ad55d7d7ce5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_nearest_neighbor.py": "21bf2be683cefa7a760bf1e1bdaa647f57bf47ab86b13fd7a74e8d650f492913", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_positive_tree.py": "46db2ce9122ff57bb4eeaa723db1f351891e671a7eaa7bf4fb61f85dafee9e37", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_q_ldu.py": "ec2589ca9abe71d674ba9ccf81f289b1526f56f3001c48d22977accb1be3e4dc", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_sylvester_factor.py": "60b21fda4ff451582087d30222a072eb1a214d531277e92883eaf28221aafced", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/FRONTIER-FUSION-ARITHMETIC.json": "82656563e7c8725f95c4aea7e273805a3d3faf34c495a330f1c91a036765414a", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-RECEIPT.json": "49a8450289f1c1730c7d11d7c1506ad4af26fe9a1f76341f808a3025123e9519", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-REVIEW.md": "b48d3e14083829db81336b639a6cfc698ac0dccc76fa2606d11b4be7a968ddeb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/NATIVE-ADMISSION-BINDING.json": "ec4e89e0513958c1d553736cd06eedbc5f2aca61b40f92aeade3eb882bf588bc", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/REPRODUCE.txt": "76808b685f1623813658f5b596a4b8191a07e7c0810550f6fada7fb4a4992913", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/T74-APPENDIX.tex": "d053a6b69de2ff4005ee52eb3b673de606326aa0f0e290354675f9f08f915b99", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/bind_native_admission.py": "166541ca2b7f3066f4c2421e5a9f1886d58e1fdd7677904976261ab2c82b32cb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/check_frontier_fusion.py": "02f7f9ebf29487331171954c7ceb37ff5315e2f28a9d56096ebbf9fb865c70ab", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/independent_substitution_check.py": "579bbde41e90792818c2726b38dcab26cf5a2695d3348731e814175146b0a737", + "vendor/pr1673/capped-phase-fusion/gaussian_fixed_width_note.tex": "6f3edb7b238f2b6af4f3e2d98dee90fe6f4ba063a5ccd120422e45c941712aab", + "vendor/pr1673/capped-phase-fusion/make_native_capsule.py": "8f342ca212b8d601a11f704042c577c1b088e0079bda04b3065467c2f3c36ea0", + "vendor/pr1673/capped-phase-fusion/phase_fusion_note.tex": "b5957f38c98a68f2584a42cedf91d753180dab438129fdf749b441074f00d4e1", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/RESULT.json": "11c57817a4d43a489010a13af7621d37eeedc398308c036e63a2a97119443861", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/STAGES.json": "c2edb01a61c03e04bf48e605422ff83c1d304e4d586268959d4ea24b743640fb", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/CLAIM.json": "70aacd45f9e6fac8675687cf50da32e0ad4e479d9a5c28f2afd1550311ae8849", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/MANIFEST.json": "d90d49eaa68e48c6992a07972e736ef4b9cd80274361cbbc1ec980d43f29ad7f", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/NOTICE": "3918a42010a435782de0fe8c38fab8f7df5d48a375ecf603c2bad1b818a16d6f", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/new/SPEC.json": "d6b6a2140f3a61ae8cfdd8b51a1131934d63d2dd8573c1b13eb2b9528f3c3db8", + "vendor/pr1673/capped-phase-fusion/verify.py": "93ef0f46e132485da6194587199b8f039e25b1b9f099f93bbdaeac5c0d66de7f", + "vendor/pr1786/FINE-PRIME-PADDING.md": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce", + "vendor/pr1786/NOTICE.md": "dcc1adb2461aa93ca62b6a912dbd8b215599e6af8053dfbacb7423b544dd659a", + "verify.py": "4dbb80917a2324b5f7bd89485963a009e54db98f99e91469811e1d36101bea95", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800" + }, + "manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "package": "research/gmx-t74-borrow43-handoff", + "repo": "philippeVV/integer-mult-bounds" +} diff --git a/research/t74-joint-twelve-retired7/SOURCE-NOTICE b/research/t74-joint-twelve-retired7/SOURCE-NOTICE new file mode 100644 index 0000000000..380e979f0e --- /dev/null +++ b/research/t74-joint-twelve-retired7/SOURCE-NOTICE @@ -0,0 +1,14 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. + +The preceding paragraphs are inherited source notices, not attribution of this derivative. +This joint twelve-source construction, generator, independent replay, hosting composition and package: Tekalign (@tekuuu), with substantial OpenAI Codex assistance. No independent human review claimed. +Credits: Cinna Davis/PR2226 anticipatory dirty borrowing; Tekalign/PR2436 four lifted targets; Jeremy Kothe/PR2462,2588,2673 source pipeline, source-label swap and order/fill; zxv/PR2530 eight aliases; Mason Hale/PR2696 concentrated source-partner assignment and independent local interpreter; Philippe Van Velzen/PR2559,2679 evacuation, six pre-life hosts and refit/alias; themilkman216/PR2621 priority order; Marius-Paul Dumitrean/PR2733 independent concentrated/pre-life composition; Vlado Vojdanovski/PR2322 generator utilities. PR2720's fixed-old-path cut obstruction motivates the changed premise. The retained owner/native/bit/modern outer lineage and their notices remain in the pinned source. New work Apache-2.0. diff --git a/research/t74-joint-twelve-retired7/SOURCES.json b/research/t74-joint-twelve-retired7/SOURCES.json new file mode 100644 index 0000000000..aa59a560ca --- /dev/null +++ b/research/t74-joint-twelve-retired7/SOURCES.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "base_commit": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "00c96932e109c701310f4910057bae2d6cec0c0f", + "sha256": "2d47ee25f6900efa3bac76f66f59cc6d6e077ed1e7301497ab332668ad288d4c" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "0515a31cd888a18e5830987da12d4051f552c8cc", + "sha256": "e3e85885c27919c4f603954ef25339e9c1be4bd107f829921078b8134b366044" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/current-status.md", + "usage": "provenance", + "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", + "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" + }, + { + "path": "research/t74-joint-twelve/README.md", + "usage": "provenance", + "git_blob": "77ab0d3121069a8aa365bf0f6c35ee8e5ac15ac8", + "sha256": "d8501fbc11b3dc87fc618122c83f10a56cd4457c7abdab792e2f9506bab4666e" + }, + { + "path": "research/t74-joint-twelve/CLAIM.json", + "usage": "provenance", + "git_blob": "48ad23a430def28e485ee311ac92828ac9664a0c", + "sha256": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438" + }, + { + "path": "research/t74-joint-twelve/verify.py", + "usage": "provenance", + "git_blob": "bae5b71ecc554b787deab407b1beb394124cf86a", + "sha256": "d97bcc7208abd7e2f6f836c5558dae93e92ebbf6b17b0f413bc6e78ac68d62fc" + }, + { + "path": "research/t74-joint-twelve/independent_owners.py", + "usage": "provenance", + "git_blob": "93270b725a4efd56b283b02f9abf7a5d0e66c55f", + "sha256": "4e0785a659b4a6516581f15476c054de1581aa4b3763ce45b1fd20e45c2bb5af" + }, + { + "path": "research/t74-joint-twelve/workflow/admit.py", + "usage": "provenance", + "git_blob": "4606a5024ee5fe12ecaf18d983f010ebd944acdd", + "sha256": "f0d510b46a5f05b033b13fecb706389ab374b783bd46ef30e7386195d9e56d3e" + }, + { + "path": "research/t74-joint-twelve/generate.py", + "usage": "provenance", + "git_blob": "82ca3d20a5e2fd8c4b67b19e9b9ecd5fca423853", + "sha256": "55d87e7490a7011d881e48f3ab946b7f8b95e0b1b3e91987a8ff8129f18d5869" + }, + { + "path": "research/t74-joint-twelve/packing_cap.py", + "usage": "provenance", + "git_blob": "dd97566afb7ac6686606b50dc644fd14a559d301", + "sha256": "86b768616359b43a4a4fe4135370c7713f9436b5009553bb8e7b984367f54593" + }, + { + "path": "research/t74-joint-twelve/test_integrity.py", + "usage": "provenance", + "git_blob": "73c4e96005f0699a05642dcc39308d4b279e2707", + "sha256": "f2cabdb261761ebfa6f9b6ed2f3aae1a0853c79bc6ddc2808c6e8bbe5b46e68b" + }, + { + "path": "research/t74-joint-twelve/full_replay.py", + "usage": "provenance", + "git_blob": "d9718b8b5b173ab81efaee24c04e5c99b6e70e94", + "sha256": "3f7ff263775253f73a87abc43a76f39f23e8bc0ce433a562d17f2c0705b5a02b" + }, + { + "path": "research/t74-joint-twelve/OVERLAY-PINS.json", + "usage": "provenance", + "git_blob": "ec223bdbe25510166f6bad3bf21d039512dc5177", + "sha256": "c5aab657b189d1324b75c2a35dd21063877229ebfd58b4b64261fdf0e5861e75" + }, + { + "path": "research/t74-joint-twelve/DERIVATIVE-OVERLAY.tar.gz", + "usage": "provenance", + "git_blob": "46f7ce76d81b9c46fde6b0fb204bcad4763e1a87", + "sha256": "16468f7428c6e01522fcb15a8e3040d13de6cb8856428e32dcfbce8dbe46b8ec" + }, + { + "path": "research/t74-joint-twelve/inputs/WORD-base.json.gz", + "usage": "provenance", + "git_blob": "f1fc67a6eaf4bcc5dfa852b448aa2659070fa5f8", + "sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a" + }, + { + "path": "research/t74-joint-twelve/inputs/WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "f06e80c4dddb9741d0051cb85a57d356e673f687", + "sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127" + }, + { + "path": "research/t74-joint-twelve/inputs/PROVIDERS.json", + "usage": "provenance", + "git_blob": "26be26b6d25be67327ae77623c2eaa0a9fe463dc", + "sha256": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66" + }, + { + "path": "research/t74-joint-twelve/inputs/FILL.json.gz", + "usage": "provenance", + "git_blob": "17129e917b31b15625c53181d303b68e17ffed55", + "sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1" + } + ] +} diff --git a/research/t74-joint-twelve-retired7/TASK.json b/research/t74-joint-twelve-retired7/TASK.json new file mode 100644 index 0000000000..61c622f03f --- /dev/null +++ b/research/t74-joint-twelve-retired7/TASK.json @@ -0,0 +1,82 @@ +{ + "schema_version": 1, + "task_id": "selected-packing", + "priority_revision": 5, + "base_commit": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "original_card": { + "id": "selected-packing", + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ], + "methods": [ + "Search a named unclaimed canonical candidate domain with a reproducible partition.", + "Prove a stronger scoped relaxation or exact optimum for one named residual subproblem." + ], + "acceptance_gate": "Check live PR overlap first, price both suppliers and distinguish a search best from an optimum. Report the word's packing cap from ceiling.ceiling() and the fraction of it realized; label packing gains as such.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Locate the selected packing source in the review and check live PRs for the same residual problem.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ] + }, + "task_classification": "Explicit coordinator assignment (joint retired-lender / lender assignment on our local retired5 words, every existing hosting movable), not a random card draw.", + "scope_status": "changed", + "actual_scope": "Extended retired-lender census on the retired5 words (PR2751 + five retired-lender aliases) treating every existing B-warp hosting as movable; two hostee moves (warps 30/31: 401->564, 403->565) with exact refits enable two more PR2679-type aliases 667<-401, 669<-403; certified frames; compacted owner fill; complete release through PR2751's own full replay.", + "scope_change_reason": "No retired lender with frame floor <= 5 retires before the four remaining rank-4 followers enter, but 24 hosted lenders do once their hostees move to the two free floor-5 lenders 564/565, which retire before the hostees enter; an exact one-rank refit of those lenders' last gates makes the moves and two more aliases feasible.", + "bottleneck_link": "Removing two more width-5 helpers per call frees 1332 hosted cells as idle 5-remainders while the certified frames merge jumps (local {1:-4,2:+6,3:-6}); the paid moment drops and the complex endpoint rises by 3.86e-7 over retired5 (6.53e-7 over PR2751, 5.38e-7 over PR2766/PR2767).", + "stop_rule": "One explicit pair of hostee moves and two aliases on both providers after an exact augmenting-path census (192 paths, at most two extra aliases); no exhaustive search over other mechanisms claimed. Stop after complete release and handoff.", + "declared_milestone": "Integrated conditional kappa, subject to the inherited all-size/interface/analytic assumptions.", + "obligation_ledger": { + "native_words": "Two new words; fresh five-stage native runs passed; PR2679/PR2751 and retired5 stage controls retained and the new refit7/hostmove2/alias7/refit7c stages carry their own tamper controls (retired7_controls.py).", + "physical_hosting": "Complete literal owner fill (271728 roles, R 408) checked by reconstruct.py and the independent integer-chronology/bit-mask checker.", + "supplier_and_outer": "Discovery/unpin/freeze, strict T74 replay and the package's own verify_release.py passed in the full cold release.", + "inherited": "All universal obligations of PR2751 and its lineage are inherited unchanged." + }, + "family_expansion_decision": "Explicit request to improve the latest pending construction; the retired-lender alias family (PR2679) is extended by an exact refit census on the new words, not reopened unchanged.", + "outcome": "completed", + "evidence": "Full cold release (four fresh native providers, retained parent, complete admission, PASS_RELEASE) and registered hook (seven-stage rebuild, pinned PR2679 auditor on eight states, 142 tamper controls, literal owner fill, exact 1e-24 bracket, 80-digit root, kappa above PR2751, PR2766, PR2767). Evidence in evidence/retired7.", + "author": "Marius-Paul Dumitrean (@mdumitrean)", + "ai_assistance": "Substantial AI assistance (Anthropic Claude, via Claude Code) in the census, augmenting-path search, pricing, stage construction, checker adaptations, certification runs and documentation. No independent human review or formal theorem claimed.", + "open_questions": [ + { + "question": "Can a gate-level (kernel) edit make the rank-1-entrance followers alias-feasible?", + "why_it_matters": "The 48 rank-1 followers are width-8 helpers (about 1e-6 relaxed value each), but every lender's exact frame floor is at least rank 4.", + "first_step": "Price single-gate kernel edits that lower one candidate lender's retirement frame floor below rank 2, with the auditor and native chain.", + "blocked_by": "No retired lender reaches rank <= 1 under any refit of the fixed gate lists." + }, + { + "question": "Can a third free floor-5 lender be opened for followers 670 and 671?", + "why_it_matters": "Each further width-5 alias of this kind priced about +1.9e-7 here.", + "first_step": "Search frame refits or gate moves that lower a free lender's floor to rank 5 with retirement before B941.", + "blocked_by": "Only 564 and 565 are free lenders with floor <= 5; both now host the moved warps." + }, + { + "question": "Do the retired5 and retired7 stages stack with PR2767's post-cut partner correction?", + "why_it_matters": "Both improve PR2751 independently; a stack could add their gains.", + "first_step": "Apply the seven stages to PR2767's words and re-run the census and the certified frames.", + "blocked_by": "PR2767's words differ from PR2751's; the stage inputs are word-specific." + } + ] +} diff --git a/research/t74-joint-twelve-retired7/VERIFY.json b/research/t74-joint-twelve-retired7/VERIFY.json new file mode 100644 index 0000000000..a4c9fb33d0 --- /dev/null +++ b/research/t74-joint-twelve-retired7/VERIFY.json @@ -0,0 +1,50 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Literal review: PR2751 construction reproduced, the seven declared stages (retired5 refit5/alias5/refit5c, retired7 refit7/hostmove2/alias7/refit7c) rebuild both candidate words, candidate fill = declared compaction (seven removed helpers), independent symbolic/frame/cleanup checks with six mutations, literal owner fill (R 408) with one mutation, exact adjacent root bracket, claim binding and strict improvement over PR2733, PR2745, PR2751, PR2766 and PR2767." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_retired7.py" + ], + "timeout_seconds": 300, + "checks": "Seven-stage structure, the pinned PR2679 auditor on all eight states, 142 tamper controls (retired5: lender refit undone by warp frame mismatch, follower raise undone, 35 alias mutations, corrupted certified frame; retired7: new-lender refit undone by warp frame mismatch, 4 controls per hostee move, the PR2679 alias suite per new alias, corrupted certified frame; every mutant re-derives its cleanup and must be rejected for a real reason), literal owner fill (R 408), 80-digit root and kappa = C - 1e-46 - 1e-70 above PR2751, PR2766 and PR2767." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/packing_cap.py" + ], + "timeout_seconds": 120, + "checks": "Pinned generic coverage-law ceiling and realized fraction for the candidate, not a sharp packing optimum." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_integrity.py" + ], + "timeout_seconds": 300, + "checks": "Git-free read-only relocation; altered claim/input and optimized execution refusals." + } + ] +} diff --git a/research/t74-joint-twelve-retired7/composition.py b/research/t74-joint-twelve-retired7/composition.py new file mode 100644 index 0000000000..bb455e907d --- /dev/null +++ b/research/t74-joint-twelve-retired7/composition.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Deterministic PR2673 priority-fill / PR2679 pre-life-word composition. + +No solver and no native execution. Match helper indices in increasing order +within each width queue, delete seven surplus width-4 roles per call, then +compact each physical bin. Helper indices are width-registry positions, not +register identities. Final whole-call geometry is checked separately by both +literal implementations in verify.py; full_replay.py binds actual natives. + +Credit Jeremy Kothe's PR2673 fill and PR2621's priority scheduling idea, +PR2679's pre-life/refit words, PR2588/PR2530 and retained supplier lineage. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys +sys.dont_write_bytecode = True + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def transform(old, new, fill, order, initial_dispatch, words): + """Reconstruct the full candidate and mapping from authenticated inputs.""" + need(set(old) == set(new) == set(words) == {'gauge44', 'extra'}, 'provider identities') + need(len(order) == 666 and len(set(map(tuple, order))) == 666, 'composition call count') + need(len(fill['rows']) == 281052, 'source role count') + dispatch = dict(initial_dispatch) + for s, r, pid in fill['dispatch_overrides']: + need((s, r) in dispatch and pid in new, 'source dispatch override') + dispatch[s, r] = pid + need(set(dispatch) == set(map(tuple, order)), 'source dispatch coverage') + maps, dropped, bindings = {}, {}, {} + for pid in sorted(new): + oldq, newq = defaultdict(list), defaultdict(list) + for i, width in enumerate(old[pid]['widths']): + oldq[width].append(i) + for i, width in enumerate(new[pid]['widths']): + newq[width].append(i) + need(len(old[pid]['widths']) == 422 and len(new[pid]['widths']) == 415, 'old/new helper counts') + need(set(oldq) == set(newq) == {4, 5, 7, 8, 9}, 'width support') + need({w:len(oldq[w])-len(newq[w]) for w in oldq} == {4:7, 5:0, 7:0, 8:0, 9:0}, 'seven surplus width-4 roles') + maps[pid] = {i:j for w in sorted(newq) for i,j in zip(oldq[w], newq[w])} + dropped[pid] = sorted(set(range(422)) - set(maps[pid])) + need(len(maps[pid]) == 415 and set(maps[pid].values()) == set(range(415)), 'new helper bijection') + need(all(old[pid]['widths'][i] == new[pid]['widths'][j] for i,j in maps[pid].items()), 'width-preserving bijection') + need(len(dropped[pid]) == 7 and all(old[pid]['widths'][i] == 4 for i in dropped[pid]), 'deleted widths') + # This binds declared widths/report to the raw word, without claiming + # that reading its report proves the actual native program semantics. + word = words[pid] + remaining = [r for r in range(224, 704) if r not in set(word['removed'])] + final = {int(k):v for k,v in word['helper_final'].items()} + extra = {int(k):v for k,v in word['start_extra'].items()} + actual = [len(final.get(r, range(9))) - len(extra.get(r, [])) for r in remaining] + need(actual == new[pid]['widths'], 'raw-word ordered width binding') + need(word['report']['local_profile'] == new[pid]['actual_paid_profile'], 'raw-word reported profile binding') + bindings[pid] = dict(helpers=len(remaining), + width_inventory=dict(sorted(Counter(actual).items()))) + rows, removed, bins, oldbins, per_call = [], [], defaultdict(list), defaultdict(list), defaultdict(set) + for i, row in enumerate(fill['rows']): + need(len(row) == 6 and all(type(v) is int for v in row), 'source role shape') + t, h, owner, child, port, offset = row + need(0 <= t < 666 and 0 <= h < 422, 'source role bounds') + need(h not in per_call[t], 'source duplicate helper') + per_call[t].add(h) + pid = dispatch[tuple(order[t])] + oldbins[owner, child, port].append(old[pid]['widths'][h]) + if h not in maps[pid]: + removed.append((owner, child, port)) + continue + bins[owner, child, port].append(len(rows)) + rows.append([t, maps[pid][h], owner, child, port, offset]) + need(set(per_call) == set(range(666)) and all(x == set(range(422)) for x in per_call.values()), 'source helper coverage') + need(len(removed) == 4662 and len(set(removed)) == 4662, '4662 distinct affected bins') + need(all(sorted(oldbins[key]) == [4, 9, 9, 9] for key in removed), 'source deletion-bin patterns') + for indices in bins.values(): + offset = 0 + for i in sorted(indices, key=lambda j:rows[j][5]): + row = rows[i] + row[5] = offset + offset += new[dispatch[tuple(order[row[0]])]]['widths'][row[1]] + need(len(rows) == 276390, 'composed role count') + candidate = dict(fill, rows=rows) + mapping = dict(keep_maps=maps, dropped=dropped) + report = dict(status='PASS_DETERMINISTIC_WIDTH_QUEUE_COMPOSITION', removed_roles=4662, + affected_bins=4662, source_bin_widths=[4, 9, 9, 9], remaining_bin_widths=[9, 9, 9], + roles=len(rows), calls=666, helpers_per_call=415, width_bindings=bindings, + fill_canonical_sha256=hashlib.sha256(canonical(candidate)).hexdigest()) + return candidate, mapping, report + + +def check(data): + obj = data['objects'] + original_order = obj['source/pr2673/ORDER.json'] + initial = {(s,r):p for s,r,p in obj['source/pr2673/DISPATCH.json.gz']} + need(initial == data['dispatch'], 'unchanged source dispatch') + candidate, mapping, report = transform( + obj['source/pr2673/PROVIDERS.json'], data['providers'], + obj['source/pr2673/FILL.json.gz'], original_order, initial, + {'gauge44':obj['source/pr2679/WORD-base.json.gz'], 'extra':obj['source/pr2679/WORD-extra.json.gz']}) + need(data['candidate_order'] == original_order, 'unchanged priority order') + need(candidate == data['candidate_fill'], 'complete deterministic candidate equality') + need(json.loads(canonical(mapping)) == obj['candidate/MAPPING.json'], 'complete deterministic mapping equality') + report['mapping_canonical_sha256'] = hashlib.sha256(canonical(json.loads(canonical(mapping)))).hexdigest() + return report diff --git a/research/t74-joint-twelve-retired7/evidence/ADMISSION.json b/research/t74-joint-twelve-retired7/evidence/ADMISSION.json new file mode 100644 index 0000000000..df8d10716f --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/ADMISSION.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "1717141586348426338109/1000000000000000000000000", + "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "gain": "6257252193655137/6250000000000000000000", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "native_receipt_sha256": "c33bf92fccb63f4d9a3ff6f7e025ac831ad012dd92d236b0f046bc4b1c6a29b2", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "32": 1, + "4": 79920, + "48": 26558, + "5": 22532, + "8": 5328 + }, + "release_receipt_sha256": "5839b3b3448d67d7a936fe962298d7d77cb83ee489321343af7769166f5d0142", + "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_commit": "local-joint12-pr2733", + "source_manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/reconstruct.py", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/owners" + ], + "exit_code": 0, + "log_sha256": "ea77455da769b04c89d99695cb56a77c635a8ff46c760b826bf79e9689baa3db", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 7.02489157000673 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/lift_parent.py", + "--owners", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/owners", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 10.359581939002965 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/new/rebind.py", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "2bebde6c85961ee26457f1a7d2fe6e6672a95aeebcd81194c7ecf30804f6346b", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 1.542834171996219 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/layout/packing74/replay.py", + "--data", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/layout/packing74/candidate", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/discovery", + "--local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "7259104fe82131c1dd33d27a26f074197ddae0190425675ba761a62c8155de98", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 117.20071977899352 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "b148cd9ee46327427df78e9e351d4d7144b62dc180fae092d82c8e51bf62b2cd", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.08087540300039109 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "edfd0610e9edc82ff330651fed281fb6e5f3b8dec5a3e48feea760009ae3c21a", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.07375459698960185 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/verify_release.py", + "--main", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/source-fixed", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/release", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "94711a507533c0e2cb36f1f9fb66dfb4f06957aa76f4f83b667e1e4e5260661f", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 395.8588478729944 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/INDEPENDENT.json b/research/t74-joint-twelve-retired7/evidence/INDEPENDENT.json new file mode 100644 index 0000000000..750227462f --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/INDEPENDENT.json @@ -0,0 +1,662 @@ +{ + "source_checker_sha256": "ab384bca6be86e5cef39b88c313113a33b4c225534f833d8fcd97b9de58cfd53", + "providers": { + "base": { + "profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "section_profiles": { + "A": { + "1": 924, + "2": 24, + "4": 56 + }, + "cut": { + "8": 8 + }, + "B": { + "1": 1078, + "2": 510, + "4": 64, + "3": 226, + "5": 26 + }, + "restore": { + "1": 47, + "2": 38, + "3": 8 + }, + "ends": { + "1": 317, + "2": 74, + "3": 63 + } + }, + "inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "center_paths": [ + { + "center": 92, + "start_rank": 8, + "target_offsets": [ + 12, + 100, + 103, + 17, + 72, + 94, + 70, + 62, + 101, + 54, + 18, + 40, + 0, + 57, + 98, + 48, + 45, + 107, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 57, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 72, + 94, + 70, + 62, + 83, + 73, + 59, + 30, + 0, + 57, + 80, + 67, + 8, + 95, + 68, + 5, + 96, + 64 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 81, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 12, + 100, + 103, + 17, + 101, + 54, + 18, + 40, + 83, + 73, + 59, + 30, + 27, + 7, + 13, + 16, + 15, + 42 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 224, + "start_rank": 8, + "target_offsets": [ + 27, + 7, + 98, + 48, + 45, + 107, + 80, + 67, + 8, + 95, + 13, + 16, + 15, + 42, + 68, + 5, + 96, + 64, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 11, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 56, + 31, + 38, + 77, + 91, + 10, + 36, + 20, + 32, + 85, + 24, + 35, + 3, + 88, + 66, + 26, + 53, + 105 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 240, + "start_rank": 8, + "target_offsets": [ + 91, + 10, + 102, + 55, + 19, + 39, + 84, + 74, + 60, + 29, + 36, + 20, + 53, + 105, + 69, + 4, + 97, + 65, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 9, + "start_rank": 8, + "target_offsets": [ + 56, + 31, + 38, + 77, + 89, + 79, + 84, + 74, + 60, + 29, + 111, + 46, + 3, + 88, + 66, + 26, + 51, + 44, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 256, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 89, + 79, + 102, + 55, + 19, + 39, + 111, + 46, + 32, + 85, + 24, + 35, + 51, + 44, + 69, + 4, + 97, + 65 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + } + ], + "cleanup": 4540, + "algebra": { + "forward": "PASS", + "dual": "PASS" + }, + "rejecting_controls": [ + "drop_anticipatory", + "reverse_anticipatory", + "drop_source_restoration" + ] + }, + "extra": { + "profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "section_profiles": { + "A": { + "1": 924, + "2": 24, + "4": 56 + }, + "cut": { + "8": 8 + }, + "B": { + "1": 1078, + "2": 510, + "4": 64, + "3": 226, + "5": 26 + }, + "restore": { + "1": 47, + "2": 38, + "3": 8 + }, + "ends": { + "1": 317, + "2": 74, + "3": 63 + } + }, + "inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "center_paths": [ + { + "center": 92, + "start_rank": 8, + "target_offsets": [ + 12, + 100, + 103, + 17, + 72, + 94, + 70, + 62, + 101, + 54, + 18, + 40, + 0, + 57, + 98, + 48, + 45, + 107, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 57, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 72, + 94, + 70, + 62, + 83, + 73, + 59, + 30, + 0, + 57, + 80, + 67, + 8, + 95, + 68, + 5, + 96, + 64 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 81, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 12, + 100, + 103, + 17, + 101, + 54, + 18, + 40, + 83, + 73, + 59, + 30, + 27, + 7, + 13, + 16, + 15, + 42 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 224, + "start_rank": 8, + "target_offsets": [ + 27, + 7, + 98, + 48, + 45, + 107, + 80, + 67, + 8, + 95, + 13, + 16, + 15, + 42, + 68, + 5, + 96, + 64, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 11, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 56, + 31, + 38, + 77, + 91, + 10, + 36, + 20, + 32, + 85, + 24, + 35, + 3, + 88, + 66, + 26, + 53, + 105 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 240, + "start_rank": 8, + "target_offsets": [ + 91, + 10, + 102, + 55, + 19, + 39, + 84, + 74, + 60, + 29, + 36, + 20, + 53, + 105, + 69, + 4, + 97, + 65, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 9, + "start_rank": 8, + "target_offsets": [ + 56, + 31, + 38, + 77, + 89, + 79, + 84, + 74, + 60, + 29, + 111, + 46, + 3, + 88, + 66, + 26, + 51, + 44, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 256, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 89, + 79, + 102, + 55, + 19, + 39, + 111, + 46, + 32, + 85, + 24, + 35, + 51, + 44, + 69, + 4, + 97, + 65 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + } + ], + "cleanup": 4540, + "algebra": { + "forward": "PASS", + "dual": "PASS" + }, + "rejecting_controls": [ + "drop_anticipatory", + "reverse_anticipatory", + "drop_source_restoration" + ] + } + }, + "status": "PASS_INDEPENDENT_LOCAL_COMPOSITION_WITH_CONTROLS" +} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/evidence/NATIVE-BASE.json b/research/t74-joint-twelve-retired7/evidence/NATIVE-BASE.json new file mode 100644 index 0000000000..fd79ad2f2a --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/NATIVE-BASE.json @@ -0,0 +1,27 @@ +[ + { + "step": "native", + "exit_code": 0, + "seconds": 1.093574318991159 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 1.2534982020006282 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 36.74402106899652 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 6.469144934992073 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 284.8359740910091 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/NATIVE-EXTRA.json b/research/t74-joint-twelve-retired7/evidence/NATIVE-EXTRA.json new file mode 100644 index 0000000000..930bbf3cd1 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/NATIVE-EXTRA.json @@ -0,0 +1,27 @@ +[ + { + "step": "native", + "exit_code": 0, + "seconds": 1.1837458390073152 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 1.2502824249968398 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 38.17951157900097 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 6.418584338010987 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 281.4837235180021 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/OWNERS.json b/research/t74-joint-twelve-retired7/evidence/OWNERS.json new file mode 100644 index 0000000000..00ff9fe9e4 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/OWNERS.json @@ -0,0 +1,26 @@ +{ + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 276390, + "calls": 666, + "helpers_per_call": 415, + "windows": 1332, + "window_sha256": "d301aa0d102381aecc3dd746c424d55ea6f4ade9f87b833c8db6d643e205c846", + "idle": { + "1": 17316, + "3": 6594, + "5": 5216, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "rank_mass": 4816512 +} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/evidence/PACKING-CAP.json b/research/t74-joint-twelve-retired7/evidence/PACKING-CAP.json new file mode 100644 index 0000000000..e304fa1a3a --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PACKING-CAP.json @@ -0,0 +1,25 @@ +{ + "status": "PASS_FIXED_WORD_PACKING_CEILING", + "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "local_per_call": { + "1": "2366", + "2": "646", + "3": "297", + "4": "120", + "5": "26", + "8": "8" + }, + "dimension": 73, + "families": 896, + "stages": 9, + "centre_rank_per_call": 64, + "max_idle_rank": 51, + "complex_cap_bracket": [ + "1750373331783/1000000000000000", + "218796666473/125000000000000" + ], + "complex_cap_upper_decimal": "0.001750373331784", + "realized_fraction_lower": "1717141586348426338109/1750373331784000000000", + "realized_fraction_decimal": "0.98101448140683022362961556380933079811273967260851", + "scope": "Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used." +} diff --git a/research/t74-joint-twelve-retired7/evidence/PR2733-CLAIM.json b/research/t74-joint-twelve-retired7/evidence/PR2733-CLAIM.json new file mode 100644 index 0000000000..e97166d501 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PR2733-CLAIM.json @@ -0,0 +1,75 @@ +{ + "status": "PASS_COMPLETE_CONDITIONAL_COMPOSITION", + "kappa": "17161404259974415161889999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017161404259974415161889999999999999999999998999999999999999999999999", + "complex_lower": "1716140425997441516189/1000000000000000000000000", + "complex_upper": "171614042599744151619/100000000000000000000000", + "global_profile": { + "1": 1595736, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "7": 2664, + "8": 2664, + "32": 1, + "48": 26558 + }, + "local_profile": { + "1": 2370, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 4, + "8": 4 + }, + "comparison": { + "pr": 2696, + "head": "5a42add713e09a8798a84d0be7a8276626d9e785", + "kappa": "1715599770234969498857/1000000000000000000000000" + }, + "gain": "5406557624720173319999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "gain_percent": "0.0315140962275816123491750493328909085601430052934617650373906", + "helpers": 415, + "calls": 666, + "roles": 276390, + "private_zero_buffers": 72, + "live": 66304, + "physical": 66801, + "rank_mass": 4816512, + "full_receipt": "evidence/full/RESULT.json", + "full_receipt_sha256": "5fdf5db9538e113011ed8f9a6b824658fa21e0444f51e9256521d0c9ad585c68", + "source2679_head": "2e2cf56521df8a2b816b2689144765ee00b69a24", + "source2679_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "source2696_head": "5a42add713e09a8798a84d0be7a8276626d9e785", + "candidate_manifest_sha256": "f9b8b8cbed9e55b32d821c50ab76fef0afb1466f29d11204254fb50d2533e680", + "coverage": { + "current_stages": 18, + "retained_parent_stages": 18, + "strict_steps": 8, + "supplier_inequalities": 47, + "modern_inequalities": 63, + "modern_negative_controls": 17, + "evidence_replays": 19, + "admission_controls": 114, + "bit_controls": 12, + "current_controller_mutations": 25, + "independent_owner_controls": 8, + "geometry_controls": 6, + "prelife_mutations_per_provider": 78, + "alias_mutations_per_provider": 7, + "native_recipe_mutations_per_provider": 13, + "dirty_columns_each_orientation": 639, + "native_operator_count": 65, + "native_physical_classes": 166, + "native_columns_per_class": 512, + "ordinary_sufficient_stages": 37 + }, + "native_and_parent_receipt_reuse": false, + "inherited_parent_geometry_reuse": true, + "selected_main_changed": false, + "human_review": false, + "proof_assistant_verified": false, + "scope": "Finite conditional construction and exact outer inequalities; inherited all-size, machine, analytic and bit assumptions remain." +} diff --git a/research/t74-joint-twelve-retired7/evidence/PR2745-CLAIM.json b/research/t74-joint-twelve-retired7/evidence/PR2745-CLAIM.json new file mode 100644 index 0000000000..abec1247c3 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PR2745-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017161404259974415161896013041594543449983294017148473346276661102545764922636862044436515522027985344855150098983775041629263547163125251675447485565747834806239987578441798524484107323821701155622513700644347867401071725594568449315612515905509495884766777581839230346402338825584407497351281622158523841356428865401099338720394236958852711790336260146409872571430665117721061110787229662189541453346975519235175074214477852592724575176166998622326679703333110937366407386120214229951631808518138363267905219813176599566097495754886721517267608875850230494908103506213162350791792331441348765518613305970280449654319065477042690202246342215539071518651408763289495785152089370669825080936842027153325568738439807598194885970251801409980086488948376188447193890829832107433406905825705915805396663182725240672176836077304022063208695113974303331915673309845548803340773541582855377159749875816944631212718991851923170152142435905798890231819219511903192222342830815515007978720397740590172699682116121332914982675237191807778248656942621543376826831174051827492854427715467348053277451337090533404165485527518485679836878102147066380869160639898847390703384489759823584393568428907697605006663034567580331614359947761732591931622309384133441737507681841821011957259754052851823112401129848773767009687002041129258012185486237367939005884767039702540144053399361647325610251525609642619783749057193121726684680919138377929721804998916785273913752644037950482372045322071573538992195433777074257109555074353721999902013276517157169940561568178386620728836049772478450854453389987158727572804602321996019260738152156757161348267887911191286780813615476385696509733698463920053360075825699816566817800871673208690336294749647427947527499679407036440023012434171281046642426063654970939957181652265529443590787097461531801386011463743969975862780264085637768256289418782679823530263960075114664371507347732276812969864267561045514124389130733313432877811559115885025512526570171968931566958796992173385070063858597422249224774059391355832669440787433006251720806671766291989349470710554806666610191428287150962949669966874896220499275076889892936459607089678667559585864417586998756676345103422137383436139164074064413916005285172972434222534980758037678651337185451875937225517472532035922749947894047044307464181536443210914044182443803479301179986710313174104876273478382938568847726302351705419077804666452283789684993513210200088330639281177607666875663921738211690621348879356694620400978434606801942412927215162093602305185615637438642656133240614451101846652516809817309035289035489847973460879066277497551043498065469308439704045371771254463714675858553654131998769759361591778931496023325741201834604057378735990243836231494186018058285686722518542636221903820347998951060107655579200518923393481166710944469301744664814911217117960681084006650202202241059630268904883784070678343948707778708019904797605161781920696887549836082383733184920473162729765214804978776850316187016051529352187958399999999999999999999998999999999999999999999999", + "kappa_rational": "17161404259974415161896013041594543449983294017148473346276661102545764922636862044436515522027985344855150098983775041629263547163125251675447485565747834806239987578441798524484107323821701155622513700644347867401071725594568449315612515905509495884766777581839230346402338825584407497351281622158523841356428865401099338720394236958852711790336260146409872571430665117721061110787229662189541453346975519235175074214477852592724575176166998622326679703333110937366407386120214229951631808518138363267905219813176599566097495754886721517267608875850230494908103506213162350791792331441348765518613305970280449654319065477042690202246342215539071518651408763289495785152089370669825080936842027153325568738439807598194885970251801409980086488948376188447193890829832107433406905825705915805396663182725240672176836077304022063208695113974303331915673309845548803340773541582855377159749875816944631212718991851923170152142435905798890231819219511903192222342830815515007978720397740590172699682116121332914982675237191807778248656942621543376826831174051827492854427715467348053277451337090533404165485527518485679836878102147066380869160639898847390703384489759823584393568428907697605006663034567580331614359947761732591931622309384133441737507681841821011957259754052851823112401129848773767009687002041129258012185486237367939005884767039702540144053399361647325610251525609642619783749057193121726684680919138377929721804998916785273913752644037950482372045322071573538992195433777074257109555074353721999902013276517157169940561568178386620728836049772478450854453389987158727572804602321996019260738152156757161348267887911191286780813615476385696509733698463920053360075825699816566817800871673208690336294749647427947527499679407036440023012434171281046642426063654970939957181652265529443590787097461531801386011463743969975862780264085637768256289418782679823530263960075114664371507347732276812969864267561045514124389130733313432877811559115885025512526570171968931566958796992173385070063858597422249224774059391355832669440787433006251720806671766291989349470710554806666610191428287150962949669966874896220499275076889892936459607089678667559585864417586998756676345103422137383436139164074064413916005285172972434222534980758037678651337185451875937225517472532035922749947894047044307464181536443210914044182443803479301179986710313174104876273478382938568847726302351705419077804666452283789684993513210200088330639281177607666875663921738211690621348879356694620400978434606801942412927215162093602305185615637438642656133240614451101846652516809817309035289035489847973460879066277497551043498065469308439704045371771254463714675858553654131998769759361591778931496023325741201834604057378735990243836231494186018058285686722518542636221903820347998951060107655579200518923393481166710944469301744664814911217117960681084006650202202241059630268904883784070678343948707778708019904797605161781920696887549836082383733184920473162729765214804978776850316187016051529352187958399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "branch": "fine source-prime padding (PR1786, chafreaky; Trudgian's prime theorem; vendor/pr1786) with the gauge-free interiors (PR1758), the radix-distributed union schedule with per-visit tag work and the explicit Strassen boundary (tau=45/16); epsilon=1-1.0009765625e-3080 is a free parameter (outer/FINE-PADDING-COMPOSITION.md): kappa = C - 1/F - B, the fixed-grid maximum (epsilon q is 1.70e-3083 below q); the structured boundary of the previous package is not used; omega_C<=9/4 not used; recertified endpoint: the supplier native endpoint is certified to 1e-3000 (accept at the endpoint, reject at endpoint + 1e-3000, repaired fine engines in integer fixed point), and all free slacks are 1e-3080 or below", + "b": "certified complex_lower - 1e-3080 (see outer/B.json)", + "outer": "PR1673 capped phase-cell fusion (Vlado Vojdanovski)", + "supplier": "PR1661 T74 pivot-566 stack with PR2226 anticipatory dirty borrowing, the PR2312 width exchange, frame refit and kernels, the PR2322 handoffs, the PR2435/PR2447 entrance raise, the PR2436 lifted-target aliases, and the PR2530 (zxv) eight source-partner aliases with an owner fill evacuated by the PR2559 (philippeVV) method; this package: six pre-life hostings (cold hosts 273, 275, 289, 291, 305, 321 host helpers 482, 483, 494, 495, 507, 519), a one-gate frame refit with the retired-lender alias 653<-563, and a new exact owner fill", + "retuned_slacks": "b = certified complex endpoint - 1e-3080, q = b - 1e-3080, r0=1e-3080, zeta=1e-3082, layout slack=1e-3080, stop=1e-3086, epsilon = 1 - (1025/1024)e-3080, floor grid 1e-3046, backoff 1e-3022; kappa = C - 1/F - B is the fixed-grid maximum (outer/RETUNED-SLACKS.md, outer/PROOF-GRID-MAX.md)", + "fixed_grid_maximum": "kappa = C - 1/F - B exactly (F = 1e3046, B = 1e-3022, C the certified complex endpoint); PR2180 / PR2161 (dataisfire) point re-derived at this endpoint; main-binding guard gaussian_above_main is the 63rd strict row" +} diff --git a/research/t74-joint-twelve-retired7/evidence/PR2751-CLAIM.json b/research/t74-joint-twelve-retired7/evidence/PR2751-CLAIM.json new file mode 100644 index 0000000000..48ad23a430 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PR2751-CLAIM.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717141586348426338109", + "complex_upper": "0.001717141586348426338110", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": 2733, + "comparison_head": "2761b52b17590b8cf94f2e410004a8252d5592dc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2745, + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "exact_claim": "evidence/PR2745-CLAIM.json" + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/PR2766-CLAIM.json b/research/t74-joint-twelve-retired7/evidence/PR2766-CLAIM.json new file mode 100644 index 0000000000..d352e67b80 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PR2766-CLAIM.json @@ -0,0 +1,26 @@ +{ + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA", + "complex_lower": "0.001717256973467002308270", + "complex_upper": "0.001717256973467002308271", + "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999", + "profile": { + "1": 1591740, + "2": 430902, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": 2751, + "comparison_head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "comparison_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "absolute_gain": "115387118575970161/1000000000000000000000000", + "relative_gain": "1153871185759701610000000000000000000000000000000000000000000000/17171415863484263381089999999999999999999998999999999999999999999999", + "relative_gain_percent_decimal": "0.006719720697076920262999344663512072867487887126182086416724216655132904", + "credited_refit_pr": 2733, + "credited_refit_head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a", + "scope": "New composition of the credited PR2733 frame refit with PR2751 joint twelve-source recovery. Complete finite native, supplier and modern outer release passed; inherited universal hypotheses and selected frontier unchanged." +} diff --git a/research/t74-joint-twelve-retired7/evidence/PR2767-OUTER-CLAIM.json b/research/t74-joint-twelve-retired7/evidence/PR2767-OUTER-CLAIM.json new file mode 100644 index 0000000000..2bb218a750 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PR2767-OUTER-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999", + "kappa_rational": "17172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "branch": "fine source-prime padding (PR1786, chafreaky; Trudgian's prime theorem; vendor/pr1786) with the gauge-free interiors (PR1758), the radix-distributed union schedule with per-visit tag work and the explicit Strassen boundary (tau=45/16); epsilon=1-1.0009765625e-3080 is a free parameter (outer/FINE-PADDING-COMPOSITION.md): kappa = C - 1/F - B, the fixed-grid maximum (epsilon q is 1.70e-3083 below q); the structured boundary of the previous package is not used; omega_C<=9/4 not used; recertified endpoint: the supplier native endpoint is certified to 1e-3000 (accept at the endpoint, reject at endpoint + 1e-3000, repaired fine engines in integer fixed point), and all free slacks are 1e-3080 or below", + "b": "certified complex_lower - 1e-3080 (see outer/B.json)", + "outer": "PR1673 capped phase-cell fusion (Vlado Vojdanovski)", + "supplier": "PR1661 T74 pivot-566 stack with PR2226 anticipatory dirty borrowing, the PR2312 width exchange, frame refit and kernels, the PR2322 handoffs, the PR2435/PR2447 entrance raise, the PR2436 lifted-target aliases, and the PR2530 (zxv) eight source-partner aliases with an owner fill evacuated by the PR2559 (philippeVV) method; this package: six pre-life hostings (cold hosts 273, 275, 289, 291, 305, 321 host helpers 482, 483, 494, 495, 507, 519), a one-gate frame refit with the retired-lender alias 653<-563, and a new exact owner fill", + "retuned_slacks": "b = certified complex endpoint - 1e-3080, q = b - 1e-3080, r0=1e-3080, zeta=1e-3082, layout slack=1e-3080, stop=1e-3086, epsilon = 1 - (1025/1024)e-3080, floor grid 1e-3046, backoff 1e-3022; kappa = C - 1/F - B is the fixed-grid maximum (outer/RETUNED-SLACKS.md, outer/PROOF-GRID-MAX.md)", + "fixed_grid_maximum": "kappa = C - 1/F - B exactly (F = 1e3046, B = 1e-3022, C the certified complex endpoint); PR2180 / PR2161 (dataisfire) point re-derived at this endpoint; main-binding guard gaussian_above_main is the 63rd strict row" +} diff --git a/research/t74-joint-twelve-retired7/evidence/PUBLIC-WRAPPER.json b/research/t74-joint-twelve-retired7/evidence/PUBLIC-WRAPPER.json new file mode 100644 index 0000000000..e705eabcff --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/PUBLIC-WRAPPER.json @@ -0,0 +1,221 @@ +{ + "cold_seconds": 543.6799636979995, + "cold_stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/verify.py" + ], + "exit_code": 0, + "log_sha256": "fdbe439b439749750ed8d662d003744807c114453487bc07699dd997bbeb3786", + "name": "literal-review", + "script_sha256": "3dfcdde58f1695878668f140efc512fc06c2a30c70c78b65334a15e81844f213", + "seconds": 8.92684423099854 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/workflow/admit.py", + "--source", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/source", + "--fill", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/inputs/FILL.json.gz", + "--order", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/inputs/ORDER.json", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache", + "--native-receipt", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/NATIVE-RECEIPT.json", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "77e1a3852e31ca96cc7b7050bfe6f4876bb74db16aa8bbb901c92872344cd014", + "name": "complete-admission", + "script_sha256": "f0d510b46a5f05b033b13fecb706389ab374b783bd46ef30e7386195d9e56d3e", + "seconds": 534.4106610509916 + } + ], + "complex_lower": "1717141586348426338109/1000000000000000000000000", + "environment": { + "executable": "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.5.4", + "scipy": "1.18.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": true, + "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "gain": "6257252193655137/6250000000000000000000", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "native_receipt_sha256": "c2559bc69911798aeb62a49aef185c0aaf28e48ad2b08041b76ee8478d27dd5c", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "32": 1, + "4": 79920, + "48": 26558, + "5": 22532, + "8": 5328 + }, + "release_receipt_sha256": "7e6114c63c133769c21ea79bb13a5cd96fe6ba0ef6a9389ea91ed1f1d206a5a4", + "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_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/reconstruct.py", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/owners" + ], + "exit_code": 0, + "log_sha256": "ea77455da769b04c89d99695cb56a77c635a8ff46c760b826bf79e9689baa3db", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 7.053403829995659 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/lift_parent.py", + "--owners", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/owners", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 10.136882726001204 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/new/rebind.py", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "2bebde6c85961ee26457f1a7d2fe6e6672a95aeebcd81194c7ecf30804f6346b", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 1.5739846880023833 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/layout/packing74/replay.py", + "--data", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/layout/packing74/candidate", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/discovery", + "--local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "7259104fe82131c1dd33d27a26f074197ddae0190425675ba761a62c8155de98", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 116.71028798099724 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "b148cd9ee46327427df78e9e351d4d7144b62dc180fae092d82c8e51bf62b2cd", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.07842145599715877 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "edfd0610e9edc82ff330651fed281fb6e5f3b8dec5a3e48feea760009ae3c21a", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.05850559000100475 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/verify_release.py", + "--main", + "/home/zoe/MP/maths/mult/t74-joint12-experiment", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/release", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "94711a507533c0e2cb36f1f9fb66dfb4f06957aa76f4f83b667e1e4e5260661f", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 397.45473003099323 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/RELEASE.json b/research/t74-joint-twelve-retired7/evidence/RELEASE.json new file mode 100644 index 0000000000..e44dc7c69b --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/RELEASE.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 1717141586348426338109/1000000... brackets the ledger's b = 171714158634842633810899999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017171415863484263381089999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 395.76 +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-RESULT.json new file mode 100644 index 0000000000..51fc187607 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-RESULT.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "214676164541936455431/125000000000000000000000", + "fill_sha256": "3501f6bd9d56d9da9fdc912d957d08077434525a804bb647df1e630fc30b6a3f", + "gain": "1268890338050127259/1000000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "native_receipt_sha256": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "release_receipt_sha256": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "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_commit": "local-joint12-pr2733", + "source_manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-STAGES.json new file mode 100644 index 0000000000..a5d5bc1130 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-STAGES.json @@ -0,0 +1,111 @@ +[ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/CERT2751.json b/research/t74-joint-twelve-retired7/evidence/retired5/CERT2751.json new file mode 100644 index 0000000000..dde7a0f3d0 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/CERT2751.json @@ -0,0 +1,199 @@ +{ + "target": "PR2751 (tekuuu, head 4cfbb0cc) words + five retired-lender aliases 606<-550, 635<-551, 637<-552, 638<-553, 639<-562", + "census": { + "followers": 57, + "lenders": 409, + "live_pairs": 3747, + "fixed_ok": 0, + "refit_ok": 35, + "helpers": [ + 606, + 635, + 637, + 638, + 639 + ], + "lenders_ok": [ + 550, + 551, + 552, + 553, + 562, + 564, + 565 + ] + }, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "literal_fill": { + "checkers": [ + "PR2745-package reconstruct.py + lift_parent.py (construction run)", + "independent_owners.py (R 410) in verify.py and verify_retired5.py", + "reconstruct.py inside the complete admission" + ], + "root80": "0.0017174093163354916434484584775411722292820274055897657035793607344277615998944" + }, + "stages": [ + { + "stage": "literal-review", + "exit_code": 0, + "seconds": 3.1 + }, + { + "stage": "native-extra", + "exit_code": 0, + "seconds": 105.6 + }, + { + "stage": "native-base", + "exit_code": 0, + "seconds": 106.5 + }, + { + "stage": "native-retained-base", + "exit_code": 0, + "seconds": 86.9 + }, + { + "stage": "native-retained-extra", + "exit_code": 0, + "seconds": 87.1 + }, + { + "stage": "retained-parent", + "exit_code": 0, + "seconds": 67.4 + }, + { + "stage": "complete-admission", + "exit_code": 0, + "seconds": 209.5 + }, + { + "stage": "admission:owners", + "exit_code": 0, + "seconds": 2.6 + }, + { + "stage": "admission:parent-lift", + "exit_code": 0, + "seconds": 3.4 + }, + { + "stage": "admission:rebind", + "exit_code": 0, + "seconds": 0.5 + }, + { + "stage": "admission:discovery", + "exit_code": 0, + "seconds": 42.9 + }, + { + "stage": "admission:outer-check_ledger.py", + "exit_code": 0, + "seconds": 0.0 + }, + { + "stage": "admission:outer-independent_check.py", + "exit_code": 0, + "seconds": 0.0 + }, + { + "stage": "admission:release", + "exit_code": 0, + "seconds": 159.6 + }, + { + "stage": "release:verify:fine-engine-oracle", + "exit_code": 0 + }, + { + "stage": "release:verify:retained-provider-and-parent-admission", + "exit_code": 0 + }, + { + "stage": "release:verify:rebuild-words-566", + "exit_code": 0 + }, + { + "stage": "release:verify:reconstruct-owners", + "exit_code": 0 + }, + { + "stage": "release:verify:lift-parent", + "exit_code": 0 + }, + { + "stage": "release:verify:rebuild-borrow-words", + "exit_code": 0 + }, + { + "stage": "release:verify:audit-local-566-base", + "exit_code": 0 + }, + { + "stage": "release:verify:audit-local-566-extra", + "exit_code": 0 + }, + { + "stage": "release:verify:rebind-566", + "exit_code": 0 + }, + { + "stage": "release:verify:lemmag-labels", + "exit_code": 0 + }, + { + "stage": "release:verify:strict-t74", + "exit_code": 0 + }, + { + "stage": "release:verify:geometry-controls", + "exit_code": 0 + } + ], + "result": { + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE", + "release": "PASS_RELEASE", + "complex_lower": "214676164541936455431/125000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "precision": "endpoint certified at 1e-24 (accept at C, reject at C+1e-24); kappa = C - 1e-46 - 1e-70 exactly", + "margins": { + "PR2751": "267729987065305339/1000000000000000000000000", + "PR2766": "76171434244667589/500000000000000000000000", + "PR2767": "1.5234286848933516942947e-07" + }, + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "cold_seconds": 473.9 + }, + "package": { + "path": "research/t74-joint-twelve-retired5", + "overlay_sha256": "4305a3b9e98145d00417ae1b27caa4d9c7eed263a29ad52389fa5ffd33714ef0", + "derived_manifest": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "claim_sha256": "405e5840859b64209687b2c58d0097d9bbbdc0e007da88d91a001ccd093a79f1" + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43base.json b/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43base.json new file mode 100644 index 0000000000..9785264a78 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43base.json @@ -0,0 +1,180 @@ +{ + "all_rejected": true, + "controls": { + "606<-550 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 63", + "real_reason": true + }, + "606<-550 warp dropped": { + "rejected": true, + "reason": "frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "real_reason": true + }, + "606<-550 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "606<-550 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "real_reason": true + }, + "606 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "635<-551 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 warp dropped": { + "rejected": true, + "reason": "frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "635<-551 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "635<-551 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "real_reason": true + }, + "635 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "637<-552 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 35", + "real_reason": true + }, + "637<-552 warp dropped": { + "rejected": true, + "reason": "frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "637<-552 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "637<-552 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "real_reason": true + }, + "637 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "638<-553 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "638<-553 warp dropped": { + "rejected": true, + "reason": "frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "638<-553 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "638<-553 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "real_reason": true + }, + "638 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "639<-562 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "639<-562 warp dropped": { + "rejected": true, + "reason": "frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "639<-562 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "639<-562 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "real_reason": true + }, + "639 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43extra.json b/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43extra.json new file mode 100644 index 0000000000..9785264a78 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43extra.json @@ -0,0 +1,180 @@ +{ + "all_rejected": true, + "controls": { + "606<-550 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 63", + "real_reason": true + }, + "606<-550 warp dropped": { + "rejected": true, + "reason": "frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "real_reason": true + }, + "606<-550 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "606<-550 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "real_reason": true + }, + "606 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "635<-551 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 warp dropped": { + "rejected": true, + "reason": "frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "635<-551 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "635<-551 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "real_reason": true + }, + "635 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "637<-552 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 35", + "real_reason": true + }, + "637<-552 warp dropped": { + "rejected": true, + "reason": "frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "637<-552 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "637<-552 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "real_reason": true + }, + "637 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "638<-553 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "638<-553 warp dropped": { + "rejected": true, + "reason": "frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "638<-553 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "638<-553 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "real_reason": true + }, + "638 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "639<-562 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "639<-562 warp dropped": { + "rejected": true, + "reason": "frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "639<-562 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "639<-562 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "real_reason": true + }, + "639 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-RESULT.json new file mode 100644 index 0000000000..d276ca96c5 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-RESULT.json @@ -0,0 +1,295 @@ +{ + "cold_seconds": 473.86783904209733, + "cold_stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/verify.py" + ], + "exit_code": 0, + "log_sha256": "f29e2b1e3f365895dbbb150a0c809a8fa8f6bd31fefe2a95d156b9ab38b1d1ac", + "name": "literal-review", + "script_sha256": "9e2255942bf283cc7402f3f2dfe9b1068004d83e54aa093680697bce5fa002e4", + "seconds": 3.138666331768036 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + ], + "exit_code": 0, + "log_sha256": "d4978b408406e14a9589e8f130cafe93ca108c61e7a1988021582d627e9ecd88", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 105.63651245832443 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + ], + "exit_code": 0, + "log_sha256": "e46f44d5369c79f4b7479bc9834993bf11a8c0a2c6c04ad6c354e4ed149533fc", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 106.45441208221018 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/gauge44-word.json.gz", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 86.9097792096436 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/extra-word.json.gz", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 87.08368291519582 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/vendor/pr1297/verify.py", + "--work", + "$WORK/retained-parent", + "--base-native-from", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 67.37584125064313 + }, + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/workflow/admit.py", + "--source", + "$WORK/source", + "--fill", + "$PACKAGE/inputs/FILL.json.gz", + "--order", + "$PACKAGE/inputs/ORDER.json", + "--native-cache", + "$WORK/native-cache", + "--native-receipt", + "$WORK/NATIVE-RECEIPT.json", + "--work", + "$WORK/admission", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "78e003fec9be06b771f97b231364c81db916f005cd61b3e4676375b18b3d42d8", + "name": "complete-admission", + "script_sha256": "68c8eda7343ba8119cfe98f464aeaf27ba61d913a2088ac4aaa74ac3b1a26ea8", + "seconds": 209.51657162606716 + } + ], + "complex_lower": "214676164541936455431/125000000000000000000000", + "environment": { + "executable": "$PYTHON", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.4.4", + "scipy": "1.17.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": false, + "fill_sha256": "3501f6bd9d56d9da9fdc912d957d08077434525a804bb647df1e630fc30b6a3f", + "gain": "1268890338050127259/1000000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "native_receipt_sha256": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "release_receipt_sha256": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "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_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-STAGES.json new file mode 100644 index 0000000000..384e4a8a7e --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-STAGES.json @@ -0,0 +1,114 @@ +[ + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/verify.py" + ], + "exit_code": 0, + "log_sha256": "f29e2b1e3f365895dbbb150a0c809a8fa8f6bd31fefe2a95d156b9ab38b1d1ac", + "name": "literal-review", + "script_sha256": "9e2255942bf283cc7402f3f2dfe9b1068004d83e54aa093680697bce5fa002e4", + "seconds": 3.138666331768036 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + ], + "exit_code": 0, + "log_sha256": "d4978b408406e14a9589e8f130cafe93ca108c61e7a1988021582d627e9ecd88", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 105.63651245832443 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + ], + "exit_code": 0, + "log_sha256": "e46f44d5369c79f4b7479bc9834993bf11a8c0a2c6c04ad6c354e4ed149533fc", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 106.45441208221018 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/gauge44-word.json.gz", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 86.9097792096436 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/extra-word.json.gz", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 87.08368291519582 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/vendor/pr1297/verify.py", + "--work", + "$WORK/retained-parent", + "--base-native-from", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 67.37584125064313 + }, + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/workflow/admit.py", + "--source", + "$WORK/source", + "--fill", + "$PACKAGE/inputs/FILL.json.gz", + "--order", + "$PACKAGE/inputs/ORDER.json", + "--native-cache", + "$WORK/native-cache", + "--native-receipt", + "$WORK/NATIVE-RECEIPT.json", + "--work", + "$WORK/admission", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "78e003fec9be06b771f97b231364c81db916f005cd61b3e4676375b18b3d42d8", + "name": "complete-admission", + "script_sha256": "68c8eda7343ba8119cfe98f464aeaf27ba61d913a2088ac4aaa74ac3b1a26ea8", + "seconds": 209.51657162606716 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/GENERATE-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired5/GENERATE-LOG.txt new file mode 100644 index 0000000000..58bf5e8244 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/GENERATE-LOG.txt @@ -0,0 +1,270 @@ +wrote $OUT/gen-out2/canonical-base.json.gz 1901 4504 42 78 +BUILT base newops 12 targets {126: [45], 153: [45], 218: [45], 164: [45], 133: [45], 149: [45], 222: [45], 159: [45], 155: [45], 190: [45], 216: [45], 211: [45]} file $OUT/gen-out2/joint/eight-alias-base.json.gz +warps 58 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 646 independent inputs +free-algebra dual PASS 646 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "eight-alias-base.json.gz", + "content_sha256": "3b3f4257310076afeb608d249a1b070ea256c6764a2a865b533876873d4d2f25", + "compressed_sha256": "fe6107728d9534ea7514c01ad1c055ed5ef281eb6f1636c3c51345e532517065", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 58, + "independent_inputs": 646, + "warps": 58, + "corrections": 0, + "restored_cold": 78, + "zero_buffers": 78, + "entering": 134, + "local_profile": { + "1": 2359, + "2": 632, + "3": 318, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5251, + "width_inventory": { + "4": 33, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 646, + "elapsed_seconds": 0.35123725049197674, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 65 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 639 independent inputs +free-algebra dual PASS 639 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-base.json.gz", + "content_sha256": "f5dc7b45551de05ac239bab283dd6b73c365c7f1a132d480c70d878eb9a41de1", + "compressed_sha256": "675cd7471865da6e762af662d0aad46c73751051a2451d4aa52bc675ea79ed89", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 65, + "independent_inputs": 639, + "warps": 65, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 133, + "local_profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5223, + "width_inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 639, + "elapsed_seconds": 0.3255330827087164, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 70 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 634 independent inputs +free-algebra dual PASS 634 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-retired5-base.json.gz", + "content_sha256": "9e290bc9f46951a66869d90036e771c6071f52198437879be33c08c05d7ad7d5", + "compressed_sha256": "30583d34f5668a0e3ff808ed49893656b027bb83e75da132f2cbd01b439cd8dd", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 70, + "independent_inputs": 634, + "warps": 70, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 128, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5198, + "width_inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 634, + "elapsed_seconds": 0.33066937513649464, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +wrote $OUT/gen-out2/canonical-extra.json.gz 1901 4504 42 78 +BUILT extra newops 12 targets {126: [45], 153: [45], 218: [45], 164: [45], 133: [45], 149: [45], 222: [45], 159: [45], 155: [45], 190: [45], 216: [45], 211: [45]} file $OUT/gen-out2/joint/eight-alias-extra.json.gz +warps 58 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 646 independent inputs +free-algebra dual PASS 646 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "eight-alias-extra.json.gz", + "content_sha256": "f4d06b9b54a124eb82083ad7720c547f9624b053283081f06e3c9dd1fc00c63f", + "compressed_sha256": "0fa262b62c1e954f6b3305c6da479e8d2d126d910c981809ed226f0d02348961", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 58, + "independent_inputs": 646, + "warps": 58, + "corrections": 0, + "restored_cold": 78, + "zero_buffers": 78, + "entering": 134, + "local_profile": { + "1": 2359, + "2": 632, + "3": 318, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5251, + "width_inventory": { + "4": 33, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 646, + "elapsed_seconds": 0.32189466804265976, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 65 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 639 independent inputs +free-algebra dual PASS 639 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-extra.json.gz", + "content_sha256": "57a1598881750f3ba3d262bb577142b723208d687f29bec848381ac8bf9487f6", + "compressed_sha256": "b7cd725e8486d0cf600aa9c3a50588c4f02bc481de404db8e7d32be3fcefcbd9", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 65, + "independent_inputs": 639, + "warps": 65, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 133, + "local_profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5223, + "width_inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 639, + "elapsed_seconds": 0.3282842505723238, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 70 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 634 independent inputs +free-algebra dual PASS 634 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-retired5-extra.json.gz", + "content_sha256": "69b82b55690b5107021947b14ab81b9bb169848667063920cc5c72d17d1d9f91", + "compressed_sha256": "e2e99424ff650e90b254981e358885ff515b43e650cd7930ba660d02e807d83d", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 70, + "independent_inputs": 634, + "warps": 70, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 128, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5198, + "width_inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 634, + "elapsed_seconds": 0.33145875111222267, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS +exit 0 diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/HOOK-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired5/HOOK-RESULT.json new file mode 100644 index 0000000000..c2f514c451 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/HOOK-RESULT.json @@ -0,0 +1,151 @@ +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED5_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 273060 + }, + "complex_lower": "214676164541936455431/125000000000000000000000", + "root_80_digits": "0.00171740931633549164344845847754117222928202740558976570357936073442776159989441", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "2.67729987065305339E-7", + "exact": "267729987065305339/1000000000000000000000000" + }, + "PR2766": { + "decimal": "1.52342868489335178E-7", + "exact": "76171434244667589/500000000000000000000000" + }, + "PR2767": { + "decimal": "1.52342868489335177055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/NATIVE-RECEIPT.json b/research/t74-joint-twelve-retired7/evidence/retired5/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..b30f12f22c --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/NATIVE-RECEIPT.json @@ -0,0 +1,127 @@ +{ + "cache_files": { + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/CACHE.json": "3a8e1a43fdffa349ce9118cfdd8aaef605b69ccfc1ae1af8f35d71c3aa9a197e", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/STEPS.json": "96a871833ed290b21e6adf82bb9b3f48d2713180a1b0ccfb2d2c1b5dc0ef7ab0", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CANONICAL-WORD.json.gz": "a43a2d003b1f5599738510bbfcd0b99df5dbcb8c6365bba9e444dee8cd87ebfc", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CLIFFORD-RECIPES.json": "4da93cfd42d30cab4e4ab0b1e7fbf531584a667e738fa3fdbcf6d6f1ef40bcbb", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CLIFFORD-REVIEW.json": "362cc95a9464f00a42c114e979207ebe1faacc4e361e50c2336ba66b14dc8b36", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/FULL-WORD.json.gz": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/INDEPENDENT-LOCAL-REPLAY.json": "3fe075d088dad87ff4476300a6aa3526c001b2825a9048b31e0ae5c218145b08", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/RESIDUAL-ADAPTERS.json": "af733093f55c810dfc709d1862c786708c600f45b0319a53879c05fbca3e7fbd", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/SCALAR-FRAME-AUDIT.json": "d5313b030f3fa5220d35f89f8f8fc86b2e6602cabd379d7bd5f36ed44bfe350e", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/WARP-RECIPE-CHECKS.json": "77bf18ae4cb3a8bedf850660a29eb51310bc55d527729f773c5d77c4594faf63", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/native.log": "7524fe7dcc731a784dd413eac9cec1315cfbf106e6b01bf50821575711f544f2", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/phases.log": "9d87e97edbc1e9f7c7efe52ae5157d71c043a7a87c04e38658497dce98ffb6bb", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "6575f1c713149ac6ff3bf393c52d5e6dbc2eb452400c170431fb1a4edeb1f96b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "5a490ae4444dd0d46b6e1896b2c4aaa08c47b450b2cac39db73e7cf82a661c0d", + "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": "129d7ec37b2ff33d6986f23a6aab15ad8a5be3f3162d757c54d46d139885f8d9", + "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": "f2f24a52e5ae920e4af9322ad0d94c9ea88ca408f1a1027e2433792255986b91", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "521b0a7de15c7b843436cf267cf3b33d157ad4ef1b1a94ef24e13668e5b058df", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "215f3f3acc8c02be35ec408984e6d9e7261c41a4c089af2671fe133323b1d869", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "ff50f7fe4101be80eb824b0ca5353edda38fc569a97db317a26a2768aa6d145f", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "5e3d10375a0a5540e8f2082797953fc02c1322a008c35f6c5149e2e752932635", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "d4e22101ed0a9e7af148b8fa2fa82f3e3133b2b6d4c9f07a73be071f5607ff6b", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/CACHE.json": "578d98897d675277781be661ed0515d24c7c4fe880ed593bf2fc8e2cfcf7e8fd", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/STEPS.json": "38cae98ac7b55cd316360467d1af056d7bd02caee0e9f85cad2995ddb7934ede", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CANONICAL-WORD.json.gz": "af947314ca54dcb046c8e7b5c9f6b5e599ccff6bae47f7e61752b168c67364ea", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CLIFFORD-RECIPES.json": "0bc2e47fcdceb7c4ade7a4e63547dae76b903b1b413eda2b83fa145343b22685", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CLIFFORD-REVIEW.json": "62c6b6edc9f5a5a6f3607c26d883a68b01132bd1702c4e40d058797877045f41", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/FULL-WORD.json.gz": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/INDEPENDENT-LOCAL-REPLAY.json": "a8853fd4a8c875cd032634de84f3079e4ff7acdf32e9cbe71b5d9f57a0515cf6", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/RESIDUAL-ADAPTERS.json": "fc9a31c8e7e76d6ee300c63fe67bffd5e36f29a495f4298877947eddbf7598e8", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/SCALAR-FRAME-AUDIT.json": "ca4d2e2f61247d608939b9447842fc2862c32864134e2cc15194b60d7698ffc5", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/WARP-RECIPE-CHECKS.json": "b458da602728252c4e45dc66278b1769364f1dc192d01e6d4b4c3e6d8a1ef8ba", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/native.log": "0914ca423784c0625f4468df4f2a7e78089a6bc8b38865ec27196dcd33d6266f", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/phases.log": "b4ce593a37eb15ad871d51fcab31c4ccdbcd079ebab95bc534cc2a5b1b1c31a6", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "6636a564339c2fd6b2b2a668029c8d3e422a460a5bc8418deab1de523a8c7cf2", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "3d4f52362da2e9cc28995cd46268c82ae803076a94a3270161102c1d0170e07a", + "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": "8c3dead2f3403ac3da93d75b553a57a5551228ed393ee837c380a0de9872c71c", + "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": "fc0c6c4182159069af394f13210a0db0c98cb0182c2293bc8477f65ac077eb42", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "a4afe4dea39737eb033756d09217457ead4be1794e6f4f75730722c22bd0d615", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "93da0be182661d2c88fd25dd3107a05687829f75f225ad9ea537cd2b94874002", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "38cae98ac7b55cd316360467d1af056d7bd02caee0e9f85cad2995ddb7934ede", + "ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "af947314ca54dcb046c8e7b5c9f6b5e599ccff6bae47f7e61752b168c67364ea", + "local/CLIFFORD-RECIPES.json": "0bc2e47fcdceb7c4ade7a4e63547dae76b903b1b413eda2b83fa145343b22685", + "local/CLIFFORD-REVIEW.json": "62c6b6edc9f5a5a6f3607c26d883a68b01132bd1702c4e40d058797877045f41", + "local/FULL-WORD.json.gz": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b", + "local/INDEPENDENT-LOCAL-REPLAY.json": "a8853fd4a8c875cd032634de84f3079e4ff7acdf32e9cbe71b5d9f57a0515cf6", + "local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "local/RESIDUAL-ADAPTERS.json": "fc9a31c8e7e76d6ee300c63fe67bffd5e36f29a495f4298877947eddbf7598e8", + "local/SCALAR-FRAME-AUDIT.json": "ca4d2e2f61247d608939b9447842fc2862c32864134e2cc15194b60d7698ffc5", + "local/WARP-RECIPE-CHECKS.json": "b458da602728252c4e45dc66278b1769364f1dc192d01e6d4b4c3e6d8a1ef8ba", + "local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "native.log": "0914ca423784c0625f4468df4f2a7e78089a6bc8b38865ec27196dcd33d6266f", + "phases.log": "b4ce593a37eb15ad871d51fcab31c4ccdbcd079ebab95bc534cc2a5b1b1c31a6", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "96a871833ed290b21e6adf82bb9b3f48d2713180a1b0ccfb2d2c1b5dc0ef7ab0", + "ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "a43a2d003b1f5599738510bbfcd0b99df5dbcb8c6365bba9e444dee8cd87ebfc", + "local/CLIFFORD-RECIPES.json": "4da93cfd42d30cab4e4ab0b1e7fbf531584a667e738fa3fdbcf6d6f1ef40bcbb", + "local/CLIFFORD-REVIEW.json": "362cc95a9464f00a42c114e979207ebe1faacc4e361e50c2336ba66b14dc8b36", + "local/FULL-WORD.json.gz": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8", + "local/INDEPENDENT-LOCAL-REPLAY.json": "3fe075d088dad87ff4476300a6aa3526c001b2825a9048b31e0ae5c218145b08", + "local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "local/RESIDUAL-ADAPTERS.json": "af733093f55c810dfc709d1862c786708c600f45b0319a53879c05fbca3e7fbd", + "local/SCALAR-FRAME-AUDIT.json": "d5313b030f3fa5220d35f89f8f8fc86b2e6602cabd379d7bd5f36ed44bfe350e", + "local/WARP-RECIPE-CHECKS.json": "77bf18ae4cb3a8bedf850660a29eb51310bc55d527729f773c5d77c4594faf63", + "local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "native.log": "7524fe7dcc731a784dd413eac9cec1315cfbf106e6b01bf50821575711f544f2", + "phases.log": "9d87e97edbc1e9f7c7efe52ae5157d71c043a7a87c04e38658497dce98ffb6bb", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + } + }, + "retained_parent_receipt_sha256": "ff50f7fe4101be80eb824b0ca5353edda38fc569a97db317a26a2768aa6d145f", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..9119865da2 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,13 @@ +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-RECEIPT.json b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..b4684a573d --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 214676164541936455431/12500000... brackets the ledger's b = 171740931633549164344799999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017174093163354916434479999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 159.58 +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-RESULT.json new file mode 100644 index 0000000000..7caccd3f8f --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-RESULT.json @@ -0,0 +1,98 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "171446487838083/100000000000000000", + "kappa_decimal": "0.00171446487838083", + "manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 273060, + "prefix_bits": 1443, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19545, + "row_limit": 20161, + "controls": { + "admission": 114, + "bit": 12, + "controller": 15, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.7939643766731024, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.1763007901608944 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4441820420324802, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.665369501337409, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.473093580454588, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 97.6485572103411, + "log_sha256": "9fde2d3b4e631660ebb5848638bb4e7bd6697fa665b2ae0560cd36c3b7e431e3" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.5301409177482128, + "log_sha256": "2b03816ce8bbfde22d7aade223f5b504ff5dd05b5fd8f789d25f1ee965152ab5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.5267670825123787, + "log_sha256": "37d013a62a467be5fceb14c22e9e7ca30259dbc78378633fb65304f1fd59686b" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.4506230838596821, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.428194791078568, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 43.606457874178886, + "log_sha256": "8c2319cf48a02955e33740c7dd082c3b8eb08f445f13bdf921a1e5d3d339d66f" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.23889125138521194, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-STAGES.json new file mode 100644 index 0000000000..aff147d9ed --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-STAGES.json @@ -0,0 +1,74 @@ +[ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.7939643766731024, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.1763007901608944 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4441820420324802, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.665369501337409, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.473093580454588, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 97.6485572103411, + "log_sha256": "9fde2d3b4e631660ebb5848638bb4e7bd6697fa665b2ae0560cd36c3b7e431e3" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.5301409177482128, + "log_sha256": "2b03816ce8bbfde22d7aade223f5b504ff5dd05b5fd8f789d25f1ee965152ab5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.5267670825123787, + "log_sha256": "37d013a62a467be5fceb14c22e9e7ca30259dbc78378633fb65304f1fd59686b" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.4506230838596821, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.428194791078568, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 43.606457874178886, + "log_sha256": "8c2319cf48a02955e33740c7dd082c3b8eb08f445f13bdf921a1e5d3d339d66f" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.23889125138521194, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } +] \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/evidence/retired5/RUNTIME-PATCHES.json b/research/t74-joint-twelve-retired7/evidence/retired5/RUNTIME-PATCHES.json new file mode 100644 index 0000000000..2fea51a3dd --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired5/RUNTIME-PATCHES.json @@ -0,0 +1,32 @@ +[ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-RESULT.json new file mode 100644 index 0000000000..4ceb18a849 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-RESULT.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "fill_sha256": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "gain": "827279060596573819/500000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "native_receipt_sha256": "5b017e61828c567bc3093df8a3e7e57230cac97c9177bd6154d2cf80ed99ba4e", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "32": 1, + "4": 85248, + "48": 26558, + "5": 27194, + "8": 5328 + }, + "release_receipt_sha256": "bc68e064840769ee819bbba0213cd7cad3c82f8b60dbe3e1c49c2e079cc33445", + "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_commit": "local-joint12-pr2733", + "source_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-STAGES.json new file mode 100644 index 0000000000..8b12d62f6f --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-STAGES.json @@ -0,0 +1,111 @@ +[ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json b/research/t74-joint-twelve-retired7/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json new file mode 100644 index 0000000000..0205988129 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json @@ -0,0 +1,66 @@ +{ + "words": "retired5 candidate words (PR2751 + five retired-lender aliases)", + "rule": "new/borrow/refit/search pairs.py: lender last event before the follower first B gate, lender untouched later, dim lo(lender last) <= dim hi(follower first); chains counted", + "helper_status": { + "touched-before-B": 286, + "restored-cold": 72, + "follower": 52 + }, + "follower_hist": { + "(1, 1, 8)": 48, + "(4, 5, 5)": 4 + }, + "lenders": 404, + "lender_lo_hist": { + "(6, 'gate', False)": 124, + "(8, 'gate', True)": 70, + "(8, 'gate', False)": 194, + "(7, 'gate', False)": 14, + "(5, 'gate', False)": 2 + }, + "direct_pairs": 0, + "chain_edges": 0, + "augmenting_paths": 192, + "paths_by_follower": { + "667": 48, + "669": 48, + "670": 48, + "671": 48 + }, + "paths_by_free_lender": { + "564": 96, + "565": 96 + }, + "movable_hosted_warps": [ + 1, + 2, + 3, + 4, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41 + ], + "max_extra_aliases": 2, + "certified_singles": { + "warps 30/31/32/41 (hostee entrance already rank 5), any follower 667/669/670/671": "local {1:-2,2:+3,3:-3}, +1.928e-7 realized over retired5", + "warp 1 (hostee raise closure 16 gates)": "local {1:+2,2:+11,3:-15,4:+4}, -3.30e-7" + }, + "chosen": "warps 30 (401->564) and 31 (403->565); aliases 667<-401, 669<-403: local {1:-4,2:+6,3:-6}, +3.857e-7 over retired5" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43base.json b/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43base.json new file mode 100644 index 0000000000..45cecc552b --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43base.json @@ -0,0 +1,130 @@ +{ + "all_rejected_for_real_reasons": true, + "controls": { + "refit7 B911 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "refit7 B912 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move30 401->564 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move30 401->564 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "move31 403->565 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move31 403->565 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667<-401 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "669<-403 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 26", + "real_reason": true + }, + "669<-403 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669<-403 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "669<-403 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "refit7c certified frame corrupted": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))", + "real_reason": true + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43extra.json b/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43extra.json new file mode 100644 index 0000000000..45cecc552b --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43extra.json @@ -0,0 +1,130 @@ +{ + "all_rejected_for_real_reasons": true, + "controls": { + "refit7 B911 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "refit7 B912 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move30 401->564 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move30 401->564 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "move31 403->565 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move31 403->565 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667<-401 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "669<-403 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 26", + "real_reason": true + }, + "669<-403 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669<-403 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "669<-403 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "refit7c certified frame corrupted": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))", + "real_reason": true + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-RESULT.json new file mode 100644 index 0000000000..5cced4b2db --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-RESULT.json @@ -0,0 +1,295 @@ +{ + "cold_seconds": 410.72115191817284, + "cold_stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/verify.py" + ], + "exit_code": 0, + "log_sha256": "2c74f838e832460b1cc61ba99ae2b041c8ada28597985d1190c703f81d5eb19b", + "name": "literal-review", + "script_sha256": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "seconds": 3.4852952491492033 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/extra-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.01782804168761 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/gauge44-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.23545237630606 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + ], + "exit_code": 0, + "log_sha256": "f9d3dd98f95cd1b5358cb889c34965e40b4422712ed3682ff507175f74ba2b42", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 107.73961633443832 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + ], + "exit_code": 0, + "log_sha256": "c9003f19404118e12ef149d3bfbbeae7ffa0fd3b7e18ad408ff172625619880a", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 109.27364500053227 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/verify.py", + "--work", + "/r10/agents/F-lenders/full7/work/retained-parent", + "--base-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 70.37898799963295 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/workflow/admit.py", + "--source", + "/r10/agents/F-lenders/full7/work/source", + "--fill", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/FILL.json.gz", + "--order", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/ORDER.json", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--native-receipt", + "/r10/agents/F-lenders/full7/work/NATIVE-RECEIPT.json", + "--work", + "/r10/agents/F-lenders/full7/work/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "eba644f08e808bfd8acb0cac6376f6064d095516bc7773d0337bf416bc406d5c", + "name": "complete-admission", + "script_sha256": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "seconds": 227.28487924858928 + } + ], + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "environment": { + "executable": "~/Desktop/dev/aigent/agi/.venv/bin/python", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.4.4", + "scipy": "1.17.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": false, + "fill_sha256": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "gain": "827279060596573819/500000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "native_receipt_sha256": "5b017e61828c567bc3093df8a3e7e57230cac97c9177bd6154d2cf80ed99ba4e", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } + ], + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "32": 1, + "4": 85248, + "48": 26558, + "5": 27194, + "8": 5328 + }, + "release_receipt_sha256": "bc68e064840769ee819bbba0213cd7cad3c82f8b60dbe3e1c49c2e079cc33445", + "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_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-STAGES.json new file mode 100644 index 0000000000..4d4b3a7915 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-STAGES.json @@ -0,0 +1,114 @@ +[ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/verify.py" + ], + "exit_code": 0, + "log_sha256": "2c74f838e832460b1cc61ba99ae2b041c8ada28597985d1190c703f81d5eb19b", + "name": "literal-review", + "script_sha256": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "seconds": 3.4852952491492033 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/extra-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.01782804168761 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/gauge44-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.23545237630606 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + ], + "exit_code": 0, + "log_sha256": "f9d3dd98f95cd1b5358cb889c34965e40b4422712ed3682ff507175f74ba2b42", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 107.73961633443832 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + ], + "exit_code": 0, + "log_sha256": "c9003f19404118e12ef149d3bfbbeae7ffa0fd3b7e18ad408ff172625619880a", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 109.27364500053227 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/verify.py", + "--work", + "/r10/agents/F-lenders/full7/work/retained-parent", + "--base-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 70.37898799963295 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/workflow/admit.py", + "--source", + "/r10/agents/F-lenders/full7/work/source", + "--fill", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/FILL.json.gz", + "--order", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/ORDER.json", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--native-receipt", + "/r10/agents/F-lenders/full7/work/NATIVE-RECEIPT.json", + "--work", + "/r10/agents/F-lenders/full7/work/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "eba644f08e808bfd8acb0cac6376f6064d095516bc7773d0337bf416bc406d5c", + "name": "complete-admission", + "script_sha256": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "seconds": 227.28487924858928 + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/HOOK-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired7/HOOK-RESULT.json new file mode 100644 index 0000000000..e29b039fd3 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/HOOK-RESULT.json @@ -0,0 +1,211 @@ +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728 + }, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "root_80_digits": "0.00171779498411863466382722991842817890408858438546231220090092725676198114516931", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "6.53397770208325718E-7", + "exact": "326698885104162859/500000000000000000000000" + }, + "PR2766": { + "decimal": "5.38010651632355557E-7", + "exact": "538010651632355557/1000000000000000000000000" + }, + "PR2767": { + "decimal": "5.38010651632355556055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-RECEIPT.json b/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..a82fb1ff37 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-RECEIPT.json @@ -0,0 +1,127 @@ +{ + "cache_files": { + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/CACHE.json": "f365738d4a566219463896730ddc6442e9a3692eec745021d9dc049ff1a21b79", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/STEPS.json": "1575294f54a7cd088abbca743e87b79931ca736b71bd2326859522d55a1f4501", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-REVIEW.json": "dc9166e75871d21e7d7e23508b204a1d77205fa24684112cd12752d26f9ed89b", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/SCALAR-FRAME-AUDIT.json": "9ebdc3ef10740edd0be047ba35d9f8508d567737a28c555f5747210ad5bf2edb", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/native.log": "66ab85b104998334f95b0078b8e6fe859d5d6005f39308d78e8e77e3b38da795", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/phases.log": "c4eeb90b233202d2cbb5a8d98b7e659b252f6603795132f07c30d15be19d9a8c", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "7158575db76d8c0016aa45b8c51d33a5cd65485fd6d75ee559f1e4f6492fbf94", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "0500d5d2f2b977db012398e5a1d7aee1a48d5ba45b47d8eccfbe526e9e2c671c", + "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": "a9d93d0bb1b3d01bb4966bd660d91094f4ba7d6e52ee19aa3550866abfd6085d", + "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": "fcbc50a1ca25c8cd8776c32efc03728c529c52ab7c5e83453a034ff0a5884732", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "9ae59372e93cf456e807ff2cbd824457f92e30f36728ec943800ca1bf7d838df", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "6c3a02ede486e8157693db43b4b117335751e31c4749f13f3c281d671861666e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "8e23031a5729041e46882e654b8ea1dba44fc01682cc3bbc354d7e0a126a1d75", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "7bbf85e49e334b5bf56227d3f0ea536ad7a60a1497316c1322108ea98b4eb924", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "531ad818e1982231b906cb2a1ff4648a8f119ef4043ac1e8abda216c63d51017", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/CACHE.json": "de531be30d5b8266573f0a20391ff5d9c246986e3dca04f3ee4808ac9f5c5fc0", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/STEPS.json": "b9a277e320cfc24843057bc977b8c855cb579340d1c396281ea2af44134a9724", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-REVIEW.json": "8838336b5dac50f7a6b1271f4653fc0e09f6aa1d1cc8104edfadfdb3a9c3cd2d", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/SCALAR-FRAME-AUDIT.json": "80a20a57c2f389c35dd1871a927febfa8b970493c6f1fa2882e758b8427f3819", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/native.log": "9743caaa1bcf00835cb3da5614f08f2bcc5954211201cdb8016dfd72fe986ed3", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/phases.log": "cb955c070e5e839c3822dabd9bf38e5c99367a7835eeb1fd9c3f20c8c5b2b81b", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "1491080d42c36a4a9ebdb8405f03acc9f01b475a643dacab7fdbaba0b3aab0bf", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "eae11302beadc4c53cbecd4121491dbea883b13c53aaca14905416eb506df070", + "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": "5c3679733c9b5790c7e8ef7fe980ae0725ec92f111c4c5178896cbe42a659ee6", + "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": "72e3af5880fe75aebdb880cd46e2ad75d50b3f58818e0a999f13ee5d5ace04cc", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "5fb0494d5f2dfeb1372dcff4940380703f3f927ae24f38009ee511825a5dbebc", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "7f2738850affa652cc3245a29580bc9d3ed4a040fe5a80049b1975b5b337b94c", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "b9a277e320cfc24843057bc977b8c855cb579340d1c396281ea2af44134a9724", + "ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "local/CLIFFORD-REVIEW.json": "8838336b5dac50f7a6b1271f4653fc0e09f6aa1d1cc8104edfadfdb3a9c3cd2d", + "local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "local/SCALAR-FRAME-AUDIT.json": "80a20a57c2f389c35dd1871a927febfa8b970493c6f1fa2882e758b8427f3819", + "local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "9743caaa1bcf00835cb3da5614f08f2bcc5954211201cdb8016dfd72fe986ed3", + "phases.log": "cb955c070e5e839c3822dabd9bf38e5c99367a7835eeb1fd9c3f20c8c5b2b81b", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "1575294f54a7cd088abbca743e87b79931ca736b71bd2326859522d55a1f4501", + "ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "local/CLIFFORD-REVIEW.json": "dc9166e75871d21e7d7e23508b204a1d77205fa24684112cd12752d26f9ed89b", + "local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "local/SCALAR-FRAME-AUDIT.json": "9ebdc3ef10740edd0be047ba35d9f8508d567737a28c555f5747210ad5bf2edb", + "local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "66ab85b104998334f95b0078b8e6fe859d5d6005f39308d78e8e77e3b38da795", + "phases.log": "c4eeb90b233202d2cbb5a8d98b7e659b252f6603795132f07c30d15be19d9a8c", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + } + }, + "retained_parent_receipt_sha256": "8e23031a5729041e46882e654b8ea1dba44fc01682cc3bbc354d7e0a126a1d75", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-STANDALONE.json b/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-STANDALONE.json new file mode 100644 index 0000000000..6646251c6f --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-STANDALONE.json @@ -0,0 +1,25 @@ +{ + "runner": "new/run_native_borrow.py (PR2745 copy with PR2751 pinned bw_audit_local.py overlay 08d5864d)", + "words": { + "base": { + "steps": [ + "PASS native 0.4", + "PASS ledgers 0.5", + "PASS local-replay 10.1", + "PASS wrappers 2.0", + "PASS phases 94.9" + ], + "rc": "rc 0" + }, + "extra": { + "steps": [ + "PASS native 0.4", + "PASS ledgers 0.5", + "PASS local-replay 10.0", + "PASS wrappers 2.0", + "PASS phases 94.1" + ], + "rc": "rc 0" + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/OWNER-CHECK.json b/research/t74-joint-twelve-retired7/evidence/retired7/OWNER-CHECK.json new file mode 100644 index 0000000000..d6c74e2ba0 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/OWNER-CHECK.json @@ -0,0 +1,65 @@ +{ + "removed": [ + 667, + 669 + ], + "dropped_roles": 1332, + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728, + "calls": 666, + "helpers_per_call": 408, + "windows": 1332, + "window_sha256": "d301aa0d102381aecc3dd746c424d55ea6f4ade9f87b833c8db6d643e205c846", + "idle": { + "1": 17316, + "3": 6594, + "5": 9878, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "rank_mass": 4816512 + }, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "idle": { + "1": 17316, + "3": 6594, + "5": 9878, + "8": 0, + "16": 0, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "root80": "0.0017177949841186346638272299184281789040885843854623122009009272567619811451693129", + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.001717794984118634663827", + "margin_over_candidate": "3.85667783143e-7" +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..065d3aa653 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,18 @@ +wrote /55/_ntn26sn71d4_4mtlsn7_v200000gn/T/tmpfv9jr2nd/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS base rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +wrote /55/_ntn26sn71d4_4mtlsn7_v200000gn/T/tmpxwxk_b0g/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS extra rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW +rc 0 diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/REGISTERED-HOOK-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired7/REGISTERED-HOOK-LOG.txt new file mode 100644 index 0000000000..4a2aa3c2d0 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/REGISTERED-HOOK-LOG.txt @@ -0,0 +1,252 @@ +CHECK Literal review: PR2751 construction reproduced, the seven declared stages (retired5 refit5/alias5/refit5c, retired7 refit7/hostmove2/alias7/refit7c) rebuild both candidate words, candidate fill = declared compaction (seven removed helpers), independent symbolic/frame/cleanup checks with six mutations, literal owner fill (R 408) with one mutation, exact adjacent root bracket, claim binding and strict improvement over PR2733, PR2745, PR2751, PR2766 and PR2767. +{ + "status": "PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY", + "roles": 271728, + "local_mutations_rejected": 6, + "owner_mutations_rejected": 1, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "complex_upper": "429448746029658665957/250000000000000000000000", + "scope": "Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate." +} +CHECK Seven-stage structure, the pinned PR2679 auditor on all eight states, 142 tamper controls (retired5: lender refit undone by warp frame mismatch, follower raise undone, 35 alias mutations, corrupted certified frame; retired7: new-lender refit undone by warp frame mismatch, 4 controls per hostee move, the PR2679 alias suite per new alias, corrupted certified frame; every mutant re-derives its cleanup and must be rejected for a real reason), literal owner fill (R 408), 80-digit root and kappa = C - 1e-46 - 1e-70 above PR2751, PR2766 and PR2767. +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728 + }, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "root_80_digits": "0.00171779498411863466382722991842817890408858438546231220090092725676198114516931", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "6.53397770208325718E-7", + "exact": "326698885104162859/500000000000000000000000" + }, + "PR2766": { + "decimal": "5.38010651632355557E-7", + "exact": "538010651632355557/1000000000000000000000000" + }, + "PR2767": { + "decimal": "5.38010651632355556055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} +CHECK Pinned generic coverage-law ceiling and realized fraction for the candidate, not a sharp packing optimum. +{ + "status": "PASS_FIXED_WORD_PACKING_CEILING", + "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "local_per_call": { + "1": "2382", + "2": "648", + "3": "268", + "4": "128", + "5": "26", + "8": "8" + }, + "dimension": 73, + "families": 896, + "stages": 9, + "centre_rank_per_call": 64, + "max_idle_rank": 51, + "complex_cap_bracket": [ + "1758085934629/1000000000000000", + "175808593463/100000000000000" + ], + "complex_cap_upper_decimal": "0.00175808593463", + "realized_fraction_lower": "1717794984118634663827/1758085934630000000000", + "realized_fraction_decimal": "0.97708249083976386253139135041007810556867284138782", + "scope": "Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used." +} +CHECK Git-free read-only relocation; altered claim/input and optimized execution refusals. +PASS_JOINT_TWELVE_RELOCATED_READ_ONLY_AND_INTEGRITY_CONTROLS +PASS_REGISTERED_RESEARCH_PACKAGE research/t74-joint-twelve-retired7 outcome=completed +rc 0 diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..b5157e14f3 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,17 @@ +wrote /r10/agents/F-lenders/full7/work/admission/release/verify/tmp/tmp5q5z4d_j/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS base rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +wrote /r10/agents/F-lenders/full7/work/admission/release/verify/tmp/tmpws2cgamq/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS extra rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-RECEIPT.json b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..37735f2254 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 1717794984118634663827/1000000... brackets the ledger's b = 171779498411863466382699999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017177949841186346638269999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 178.29 +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-RESULT.json new file mode 100644 index 0000000000..680f2d73e5 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-RESULT.json @@ -0,0 +1,98 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "1714849224721887/1000000000000000000", + "kappa_decimal": "0.001714849224721887", + "manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 271728, + "prefix_bits": 1443, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19545, + "row_limit": 20161, + "controls": { + "admission": 114, + "bit": 12, + "controller": 15, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.803630419075489, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.18620125018060207 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4626617915928364, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.719976831227541, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.5223765429109335, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 119.44411616958678, + "log_sha256": "f5a192c4bc04d9f0e5dfd66d7637bd407e1b2246b97b3834897addc53628dfd6" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.6294267904013395, + "log_sha256": "4f0c4a586307535773c34b72711598f9a4f87eb530567d16b41c59ac69779af5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.6089366264641285, + "log_sha256": "005e1643b19a9951e0c5715153a44c62abdf540719ec725ae8230081c5f42335" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.5283321235328913, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.94623183272779, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 39.691487001255155, + "log_sha256": "920307b299933c8879b991b2293674236e8cbab497bbf2bfc1bb3af8bdaa4821" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.24792424961924553, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-STAGES.json b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-STAGES.json new file mode 100644 index 0000000000..3686810428 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-STAGES.json @@ -0,0 +1,74 @@ +[ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.803630419075489, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.18620125018060207 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4626617915928364, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.719976831227541, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.5223765429109335, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 119.44411616958678, + "log_sha256": "f5a192c4bc04d9f0e5dfd66d7637bd407e1b2246b97b3834897addc53628dfd6" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.6294267904013395, + "log_sha256": "4f0c4a586307535773c34b72711598f9a4f87eb530567d16b41c59ac69779af5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.6089366264641285, + "log_sha256": "005e1643b19a9951e0c5715153a44c62abdf540719ec725ae8230081c5f42335" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.5283321235328913, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.94623183272779, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 39.691487001255155, + "log_sha256": "920307b299933c8879b991b2293674236e8cbab497bbf2bfc1bb3af8bdaa4821" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.24792424961924553, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RESEARCH-TESTS-LOG.txt b/research/t74-joint-twelve-retired7/evidence/retired7/RESEARCH-TESTS-LOG.txt new file mode 100644 index 0000000000..b0448692e4 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RESEARCH-TESTS-LOG.txt @@ -0,0 +1,13 @@ +le> +AssertionError: invalid fixture +Traceback (most recent call last): + File "", line 1, in +AssertionError: invalid fixture +....CHECK Scoped test fixture +PASS_REGISTERED_RESEARCH_PACKAGE research/fixture outcome=partial +CHECK Scoped test fixture +................sss...... +---------------------------------------------------------------------- +Ran 69 tests in 5.817s + +OK (skipped=3) diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/RUNTIME-PATCHES.json b/research/t74-joint-twelve-retired7/evidence/retired7/RUNTIME-PATCHES.json new file mode 100644 index 0000000000..ce6e8881de --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/RUNTIME-PATCHES.json @@ -0,0 +1,32 @@ +[ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + } +] diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/STAGES7.json b/research/t74-joint-twelve-retired7/evidence/retired7/STAGES7.json new file mode 100644 index 0000000000..1e3fe61a7d --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/STAGES7.json @@ -0,0 +1,136 @@ +{ + "base": { + "refit7": 2, + "hostmove2_edits": 28, + "alias2_edits": 28, + "refit7c": [ + [ + "B", + 1170 + ], + [ + "B", + 1171 + ] + ], + "profiles": { + "refit7": { + "1": 2388, + "2": 646, + "3": 268, + "4": 130, + "5": 26, + "8": 8 + }, + "hostmove2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 28, + "8": 8 + }, + "alias2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "retired7": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "audits": { + "refit7": [ + 0, + "PASS" + ], + "hostmove2": [ + 0, + "PASS" + ], + "alias2": [ + 0, + "PASS" + ], + "retired7": [ + 0, + "PASS" + ] + } + }, + "extra": { + "refit7": 2, + "hostmove2_edits": 28, + "alias2_edits": 28, + "refit7c": [ + [ + "B", + 1170 + ], + [ + "B", + 1171 + ] + ], + "profiles": { + "refit7": { + "1": 2388, + "2": 646, + "3": 268, + "4": 130, + "5": 26, + "8": 8 + }, + "hostmove2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 28, + "8": 8 + }, + "alias2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "retired7": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "audits": { + "refit7": [ + 0, + "PASS" + ], + "hostmove2": [ + 0, + "PASS" + ], + "alias2": [ + 0, + "PASS" + ], + "retired7": [ + 0, + "PASS" + ] + } + } +} diff --git a/research/t74-joint-twelve-retired7/evidence/retired7/VERIFY-RESULT.json b/research/t74-joint-twelve-retired7/evidence/retired7/VERIFY-RESULT.json new file mode 100644 index 0000000000..8b8cb29852 --- /dev/null +++ b/research/t74-joint-twelve-retired7/evidence/retired7/VERIFY-RESULT.json @@ -0,0 +1,9 @@ +{ + "status": "PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY", + "roles": 271728, + "local_mutations_rejected": 6, + "owner_mutations_rejected": 1, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "complex_upper": "429448746029658665957/250000000000000000000000", + "scope": "Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate." +} diff --git a/research/t74-joint-twelve-retired7/exact_moment.py b/research/t74-joint-twelve-retired7/exact_moment.py new file mode 100644 index 0000000000..30dc8aa229 --- /dev/null +++ b/research/t74-joint-twelve-retired7/exact_moment.py @@ -0,0 +1,51 @@ +# SPDX-License-Identifier: Apache-2.0 +# Tekalign with substantial OpenAI Codex assistance. +from fractions import Fraction as F +DIMENSION=73 +def require(condition, message): + if not condition: + raise ValueError(message) + + +def log_reduced(x): + """Forty atanh terms with their positive geometric tail.""" + require(1 <= x <= 2, 'log reduction range') + t = (x - 1) / (x + 1) + lower = sum((2 * t ** (2 * j + 1) / (2 * j + 1) + for j in range(40)), F(0)) + tail = 2 * t ** 81 / (81 * (1 - t * t)) + return lower, lower + tail + + +def log_bounds(x): + require(x >= 1, 'positive logarithm range') + power = 0 + while x >= 2: + x /= 2 + power += 1 + a, b = log_reduced(x) + c, d = log_reduced(F(2)) + return a + power * c, b + power * d + + +def exp_bounds(x): + """Taylor terms 0..15; later term ratios are bounded by x/17.""" + require(0 <= x < F(1, 100), 'exponential argument range') + term, lower = F(1), F(1) + for n in range(1, 16): + term = term * x / n + lower += term + tail = term * x / 16 / (1 - x / 17) + return lower, lower + tail + + +def moment_bounds(profile, exponent): + lower = upper = F(0) + for rank, count in sorted(profile.items()): + log_lo, log_hi = log_bounds(F(DIMENSION, rank)) + exp_lo, _ = exp_bounds(exponent * log_lo) + _, exp_hi = exp_bounds(exponent * log_hi) + weight = F(count * rank, DIMENSION) + lower += weight * exp_lo + upper += weight * exp_hi + return lower, upper diff --git a/research/t74-joint-twelve-retired7/full_replay.py b/research/t74-joint-twelve-retired7/full_replay.py new file mode 100644 index 0000000000..d9718b8b5b --- /dev/null +++ b/research/t74-joint-twelve-retired7/full_replay.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Cold reproduction of the joint twelve-source/pre-life composition. + +Default: authenticated source download, fresh native providers and retained +parent admission, then the complete original supplier/release verifier. An +explicit --prepared-native-cache must match every published reuse file hash. +All large/generated artifacts remain under a fresh external --work directory. +""" +import argparse +from concurrent.futures import ThreadPoolExecutor +from fractions import Fraction as Q +import gzip +import hashlib +import importlib +import json +import os +from pathlib import Path, PurePosixPath +import platform +import shutil +import subprocess +import sys +import tarfile +import threading +import time +from urllib.parse import quote +from urllib.request import Request, urlopen + +HERE = Path(__file__).resolve().parent +REPOSITORY = HERE.parents[1] +STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unauthenticated symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def safe(name): + path = PurePosixPath(name) + need(isinstance(name, str) and '\\' not in name and path.parts and not path.is_absolute() + and '..' not in path.parts and path.as_posix() == name, 'unsafe source path') + + +def download(url, expected): + for attempt in range(3): + try: + req = Request(url, headers={'User-Agent': 'integer-mult-prelife-priority/1', 'Accept-Encoding': 'identity'}) + with urlopen(req, timeout=90) as response: + body = response.read() + need(hashlib.sha256(body).hexdigest() == expected, 'download hash mismatch') + return body + except (OSError, RuntimeError): + if attempt == 2: + raise + time.sleep(attempt + 1) + + +def source_copy(source, destination, pins, jobs): + destination.mkdir() + entries = {'MANIFEST.json': pins['manifest_sha256'], **pins['files']} + need(len(pins['files']) == pins['count'] == 491, 'source file count') + + def copy(item): + name, digest = item + safe(name) + target = destination / name + target.parent.mkdir(parents=True, exist_ok=True) + if source: + need(not (source / name).is_symlink(), 'source symlink') + body = (source / name).read_bytes() + need(hashlib.sha256(body).hexdigest() == digest, 'source bytes: ' + name) + else: + body = download(pins['base_url'] + quote(name, safe='/'), digest) + target.write_bytes(body) + + with ThreadPoolExecutor(max_workers=min(jobs, 8)) as pool: + for _ in pool.map(copy, sorted(entries.items())): + pass + need(read(destination / 'MANIFEST.json') == pins['files'] + and tree(destination) == entries, 'complete source authentication') + + +def bind_native(entry, word): + need(gzip.decompress((entry / 'local/FULL-WORD.json.gz').read_bytes()) == gzip.decompress(word.read_bytes()), + 'native complete word binding') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == STEPS and all(s['exit_code'] == 0 for s in stages), 'native stage coverage') + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--source', type=Path, help='Exact original PR2679 package directory; otherwise download pinned files.') + ap.add_argument('--work', type=Path, required=True) + ap.add_argument('--prepared-native-cache', type=Path, help='Explicit reuse of the complete published pinned cache.') + ap.add_argument('--jobs', type=int, default=4) + a = ap.parse_args() + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + versions = {} + for name in ('numpy', 'sympy', 'scipy', 'mpmath'): + try: + versions[name] = str(importlib.import_module(name).__version__) + except ImportError as exc: + raise RuntimeError('install requirements.txt in this Python environment before full replay') from exc + need(versions['sympy'] == '1.14.0', 'pinned predecessor evidence requires sympy==1.14.0') + work = a.work.resolve() + need(not work.exists() and not work.is_relative_to(REPOSITORY), 'fresh external work required') + for path in (a.source, a.prepared_native_cache): + need(path is None or (path.is_dir() and not work.is_relative_to(path.resolve())), 'input/work separation') + pins, reuse, claim = read(HERE / 'SOURCE-FILES.json'), read(HERE / 'REUSE-PINS.json'), read(HERE / 'CLAIM.json') + work.mkdir(parents=True) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1') + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, lock = [], threading.Lock() + started = time.monotonic() + + def run(name, script, *args): + begin = time.monotonic() + log = work / (name + '.log') + command = [sys.executable, '-B', str(script), *map(str, args)] + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + with lock: + stages.append(dict(name=name, command=command, exit_code=result.returncode, + script_sha256=sha(script), seconds=time.monotonic()-begin, log_sha256=sha(log))) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + run('literal-review', HERE / 'verify.py') + source = work / 'source' + source_copy(a.source.resolve() if a.source else None, source, pins, a.jobs) + overlay = read(HERE / 'OVERLAY-PINS.json') + need(sha(source/'MANIFEST.json') == overlay['original_manifest_sha256'], 'overlay base manifest') + need(sha(HERE/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive') + with tarfile.open(HERE/'DERIVATIVE-OVERLAY.tar.gz') as archive: + members=archive.getmembers() + need(set(m.name for m in members)==set(overlay['files']) and len(members)==len(overlay['files']), 'exact overlay paths') + for member in members: + safe(member.name);need(member.isfile(), 'regular overlay file') + body=archive.extractfile(member).read() + need(hashlib.sha256(body).hexdigest()==overlay['files'][member.name], 'overlay member hash') + (source/member.name).write_bytes(body) + need(sha(source/'MANIFEST.json')==overlay['derived_manifest_sha256'] and + tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'), 'complete derived source tree') + pins=dict(pins,commit='local-joint12-pr2733',manifest_sha256=overlay['derived_manifest_sha256']) + cache = work / 'native-cache' + if a.prepared_native_cache: + need(tree(a.prepared_native_cache.resolve()) == reuse['cache_files'], 'published complete cache pins') + shutil.copytree(a.prepared_native_cache.resolve(), cache) + native_receipt = reuse + else: + cache.mkdir() + layout = work / 'retained-layout' + layout.mkdir() + old = source / 'vendor/pr1297' + with tarfile.open(old / 'upstream-layout.tar.gz') as archive: + need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + for m in archive.getmembers()), 'retained archive paths') + archive.extractall(layout, filter='data') + retained_driver = layout / 'joint1148-round45/source/research/k8-eight-ends/replay_native.py' + words = {'base': source / 'new/borrow/words/BORROW-WORD-43base.json.gz', + 'extra': source / 'new/borrow/words/BORROW-WORD-43extra.json.gz', + 'retained-base': old / 'gauge44-word.json.gz', 'retained-extra': old / 'extra-word.json.gz'} + + def fresh_native(tag): + word = words[tag] + entry = cache / sha(word) + script = retained_driver if tag.startswith('retained-') else source / 'new/run_native_borrow.py' + run('native-' + tag, script, word, entry) + bind_native(entry, word) + write(entry / 'CACHE.json', dict(word_sha256=sha(word), files=tree(entry))) + + with ThreadPoolExecutor(max_workers=min(a.jobs, 4)) as pool: + for _ in pool.map(fresh_native, words): + pass + run('retained-parent', old / 'verify.py', '--work', work / 'retained-parent', + '--base-native-from', cache / sha(words['retained-base']), + '--extra-native-from', cache / sha(words['retained-extra'])) + parent = read(work / 'retained-parent/RESULT.json') + need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'fresh retained parent admission') + pm = sha(old / 'MANIFEST.json') + receipts = cache / '_receipts' / pm + receipts.mkdir(parents=True) + for name in ('RESULT.json', 'STAGES.json'): + shutil.copy2(work / 'retained-parent' / name, receipts / name) + write(receipts / 'RECEIPT.json', dict(schema='parent-receipt/1', vendor_manifest_sha256=pm, + claim_sha256=sha(old / 'CLAIM.json'), words={tag:sha(words['retained-'+tag]) for tag in ('base','extra')}, + files={name:sha(receipts / name) for name in ('RESULT.json','STAGES.json')})) + providers = {tag:dict(word_sha256=sha(words[tag]), complete_native_files=tree(cache / sha(words[tag]), ('CACHE.json',))) + for tag in ('base','extra')} + native_receipt = dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE', + source_commit=pins['commit'], manifest_sha256=pins['manifest_sha256'], providers=providers, + retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), cache_files=tree(cache)) + write(work / 'NATIVE-RECEIPT.json', native_receipt) + run('complete-admission', HERE / 'workflow/admit.py', '--source', source, + '--fill', HERE / 'inputs/FILL.json.gz', '--order', HERE / 'inputs/ORDER.json', + '--native-cache', cache, '--native-receipt', work / 'NATIVE-RECEIPT.json', + '--work', work / 'admission', '--jobs', a.jobs) + result = read(work / 'admission/RESULT.json') + need(result['status'] == 'PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE' + and Q(result['kappa']) == Q(claim['kappa']) and Q(result['complex_lower']) == Q(claim['complex_lower']), + 'published complete claim binding') + need(result['profile'] == {str(k):v for k,v in read(HERE / 'CLAIM.json')['profile'].items()}, 'published complete profile binding') + result.update(status='PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache), + source_files_sha256=sha(HERE / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'), + cold_stages=stages, cold_seconds=time.monotonic()-started, + environment=dict(python=platform.python_version(), executable=sys.executable, versions=versions)) + write(work / 'RESULT.json', result) + print(result['status'], result['kappa_decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve-retired7/generate.py b/research/t74-joint-twelve-retired7/generate.py new file mode 100644 index 0000000000..dafca20149 --- /dev/null +++ b/research/t74-joint-twelve-retired7/generate.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Rebuild the changed twelve-alias word and PR2679 pre-life/refit composition. +Pristine source is authenticated; only a fresh output directory is written. +""" +from pathlib import Path +import argparse,copy,gzip,hashlib,json,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import joint_engine as J +ASSIGNMENTS=[(696,33,49),(697,55,101),(698,74,83),(700,85,98),(680,49,33),(681,83,74),(682,98,85),(684,101,55),(688,68,4),(689,80,88),(690,88,80),(692,31,12)] +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def wr(p,w):p.write_bytes(gzip.compress((json.dumps(w,sort_keys=True,separators=(',',':'))+'\n').encode(),mtime=0)) +def main(): + need(__debug__,'assertions must be enabled') + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + source=a.source.resolve();out=a.out.resolve();pins=rd(HERE/'GENERATOR-PINS.json') + sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() + need(sha(source/'MANIFEST.json')==pins['pr2679_manifest'],'PR2679 source manifest') + need(all(sha(source/k)==v for k,v in rd(source/'MANIFEST.json').items()),'complete source files') + need(all(sha(HERE/k)==v for k,v in pins['vendor'].items()),'vendor sources') + need(not out.exists() and not out.is_relative_to(source),'fresh separate output required');out.mkdir(parents=True) + S=source/'new/borrow';sys.path[:0]=[str(S),str(S/'prelife/search')] + import build_word,word_patch as W,prelife2 as P,repair2,alias_build as AB,audit_local as AU + for canon,tag,h in [('gauge44','base','eeb6a236'),('extra','extra','cd417b90')]: + f=out/f'canonical-{tag}.json.gz';build_word.main(str(S/f'inputs/{canon}.canonical.json.gz'),str(S/'inputs/blocks.json'),str(S/f'inputs/witness_43_{tag}.json'),str(f),h);w=rd(f) + patch=rd(S/f'inputs/refit_43{tag}.json') + for sec,i,frame in patch['frames']:w[sec][i][-1]=frame + w['report']['local_profile']=patch['local_profile'];w['cleanup']=W.derive_cleanup(w,W.restored_of(w)) + w=W.apply_kernel(w,rd(S/f'inputs/kernel_43{tag}.json')) + for name in ['handoff','entrance']:w=W.apply_handoff(w,rd(S/f'inputs/{name}_43{tag}.json')) + need(W.apply_lowfour(w,rd(S/f'inputs/lowfour_43{tag}.json'))==rd(HERE/f'inputs/POSITIVE2462-{tag}.json.gz'),'complete PR2462 positive reconstruction') + w['prelude_events']=0;w=J.make(source,out/'joint',tag,seed=w,assignments=ASSIGNMENTS) + patch=rd(S/f'inputs/prelife_43{tag}.json') + for pair in patch['pairs']: + host,borrower=pair['h'],pair['L'];E=next(x[4] for x in patch['fields']['warps'][58:] if x[1]==host) + P.TRACE,_=repair2.run(copy.deepcopy(w),None);w=P.build(w,borrower,host,E) + indices=[i for i,g in enumerate(w['B']) if g[:5]==['add',515,563,1,1]];need(len(indices)==1,'unique refit gate') + w['B'][indices[0]][-1]=rd(S/f'inputs/refit563_43{tag}.json')['frames'][0][-1] + w,_=AB.alias(w,653,563);lp,wi=AB.profile(w);w['report'].update(local_profile=lp,width_inventory=wi) + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') + # retired5 + retired7: the declared stages refit5 -> alias5 -> refit5c -> refit7 -> hostmove2 -> alias7 -> refit7c turn the regenerated PR2751 word into the candidate word + for st in ('refit5','alias5','refit5c','refit7','hostmove2','alias7','refit7c'): + p_=rd(HERE/f'inputs/{st}_43{tag}.json') + if st in ('alias5','hostmove2','alias7'):w=W.apply_lowfour(w,p_) + else: + w=copy.deepcopy(w) + for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st in ('refit5c','refit7','refit7c'),'refit gate');w[sec][i][-1]=frame + w['report']['local_profile']=p_['local_profile'] + f=out/f'WORD-retired7-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired7-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') + print('PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS') +if __name__=='__main__':main() diff --git a/research/t74-joint-twelve-retired7/independent_local.py b/research/t74-joint-twelve-retired7/independent_local.py new file mode 100644 index 0000000000..e0b556adc3 --- /dev/null +++ b/research/t74-joint-twelve-retired7/independent_local.py @@ -0,0 +1,161 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Mason Hale/Codex PR2696 literal replay, extended by Tekalign/Codex. +Adds anticipatory corrections, checks six pre-life hosts and checks all twelve +source-recovery assertions at operator IDs47 through58. +""" +import json,gzip,hashlib +from collections import Counter,defaultdict +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +@lru_cache(None) +def span(vs): + s={0} + for v in vs:s|={x^v for x in tuple(s)} + return frozenset(s) +def S(vs):return span(tuple(vs)) +def rank(vs):return len(S(vs)).bit_length()-1 +def dm(s):return len(s).bit_length()-1 +FULL=S([1<>i&1:a^=c + return a +def regs(g):return g[1:3] if g[0]=='add' else g[1:2] +def nt(r):return not 112<=r<224 +def load(p):return json.loads(gzip.decompress(p.read_bytes())) +def chronological(w): + d=defaultdict(list) + for op,(p,r,*_) in enumerate(w['warps'],1):d[p].append(['warp',r,op]) + b=[] + for i in range(len(w['B'])+1): + b+=d[i] + if i0 else (new,old) + assert frozenset(im(cols,x) for x in S(a))==S(b) + cur[r]=S(new) + for g in w['A']: + if g[0]=='warp':warp(*g[1:]) + else: + for r in regs(g):climb(r,g[-1]) + bysection['A']=dict(counts);prev=counts.copy() + lev={int(k):S(v) for k,v in w['target_levels'].items()} + assert all(cur[112+t]==lev.get(t,S([])) for t in range(112)) + paths=[] + for r,vs in zip(w['centers'],w['center_frames']): + s=S(vs);assert cur[r]==s + targets=[g[1]-112 for g in w['cut'] if g[2]==r] + frames=sorted({lev.get(t,S([])) for t in targets},key=lambda s:-len(s)) + ds=[] + for f in frames: + assert f<=s + d=dm(s)-dm(f) + if d:counts[d]+=1;ds.append(d) + s=f + paths.append({'center':r,'start_rank':rank(vs),'target_offsets':targets,'reader_lines':[sorted(f-{0}) for f in frames],'paid_degrees':ds}) + bysection['cut']=dict(counts-prev);prev=counts.copy() + ops=defaultdict(list) + for op,rec in enumerate(w['warps'],1):ops[rec[0]].append((op,rec)) + for i in range(len(w['B'])+1): + for op,(_,r,cols,old,new) in ops[i]:warp(r,op,old,new) + if i=224) + assert counts==Counter({int(k):v for k,v in w['report']['local_profile'].items()}) + assert inventory==Counter({int(k):v for k,v in w['report']['width_inventory'].items()}) + return {'profile':dict(sorted(counts.items())),'section_profiles':bysection,'inventory':dict(sorted(inventory.items())),'center_paths':paths},start,ends + +def check_cleanup(w): + restored=set(map(int,w['helper_final'])) + cold=lambda r:r+704 if r in restored else r + forward=w['A'][w['prelude_events']:]+chronological(w)+w['restore'] + expected=[] + for g in reversed(forward): + if g[0]=='warp':expected.append(['warp',cold(g[1]),-g[2]]) + elif nt(g[1]): + if g[0]=='add':expected.append(['add',cold(g[1]),cold(g[2]),-g[3],g[4]]) + else:expected.append(['scale',cold(g[1]),g[3],g[2]]) + assert expected==[g[:-1] for g in w['cleanup']] + assert all(S(g[-1])==FULL for g in w['cleanup']) + return len(expected) + +def algebra(w): + # A monomial records its operations oldest-first; appending an inverse + # cancels the newest symbol. No native/generator/audit modules imported. + live=set(range(704))-set(w['removed']);cold=set(map(int,w['helper_final'])) + assert all(112<=x['target']<224 and x['source'] in {273,275,289,291,305,321} for x in w['initial_corrections']) + program=[['correction',x] for x in w['initial_corrections']]+w['precondition']+w['compensation']+w['A']+w['cut']+chronological(w)+w['restore'] + result={} + for dual in [False,True]: + rows={r:{(r,()):F(1)} for r in live} + rows.update({704+r:{} for r in cold}) + def apply(g): + op=g[0] + if op=='correction': + x=g[1];t,s=x['target'],x['source'];q=F(x['coefficient']) + ops=list(reversed(x['operator_word'])) + if dual: + t,s,q=s,t,-q + ops=[-(abs(v)+1000)*(1 if v>0 else -1) for v in x['operator_word']] + for (r,word),c in list(rows[s].items()): + for v in ops:word=word[:-1] if word and word[-1]==-v else word+(v,) + key=(r,word);value=rows[t].get(key,F(0))+q*c + if value:rows[t][key]=value + else:rows[t].pop(key,None) + elif op=='add': + t,s=g[1:3];q=F(g[3],g[4]);assert t!=s + if dual:t,s,q=s,t,-q + for term,c in list(rows[s].items()): + v=rows[t].get(term,F(0))+q*c + if v:rows[t][term]=v + else:rows[t].pop(term,None) + elif op=='scale': + q=F(g[2],g[3]);q=1/q if dual else q + rows[g[1]]={term:q*c for term,c in rows[g[1]].items()} + elif op=='warp': + d=g[2] + if not dual and 460 else -1) + rows[g[1]]={(r,word[:-1] if word and word[-1]==-d else word+(d,)):c for (r,word),c in rows[g[1]].items()} + else:raise AssertionError(op) + for g in program:apply(g) + if not dual: + assert all(rows[112+t]=={(112+t,()):F(1),(t,()):F(1)} for t in range(112)) + assert all(rows[r]=={(r,()):F(1)} for r in cold) + assert all(not any(var in cold-{r} for (var,word) in rows[r]) for r in live) + for g in w['cleanup']:apply(g) + for r in live: + exp={(r,()):F(1)} + if dual and r<112:exp[(112+r,())]=F(-1) + if not dual and 112<=r<224:exp[(r-112,())]=F(1) + assert rows[r]==exp,(dual,r,rows[r]) + assert all(not rows[704+r] for r in cold) + result['dual' if dual else 'forward']='PASS' + return result diff --git a/research/t74-joint-twelve-retired7/independent_owners.py b/research/t74-joint-twelve-retired7/independent_owners.py new file mode 100644 index 0000000000..b196522f05 --- /dev/null +++ b/research/t74-joint-twelve-retired7/independent_owners.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Independent integer-time chronology and bit-mask whole-fill verification. + +No retained window code, donor generator, solver or native checker is imported. +Credit PR2679's pre-life/refit words, PR2673/PR2621 priority scheduling, +PR2588's swapped words, PR2559's evacuation, PR2530's source-partner +fill and the PR2462/PR2322/PR2436 lineage; +Hao Yan and the retained controller authors supply the underlying schedule. +This checks a finite hosting witness, not native circuitry or an exponent. +""" +import argparse +import sys +sys.dont_write_bytecode=True +import gzip +import hashlib +import json +from collections import Counter +from pathlib import Path + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def windows(template, order): + ranks={c['child']:c['rank'] for c in template['idle_children']} + pairs={e['stage']:e['pair'] for e in template['recipe'] if e['kind']=='local'} + blocks={};stage=None + for event in template['execution_schedule']: + if event['kind'] in ('bank_padding_cover_sweep','translate_every_live_family'): + continue + if event['kind']=='local_cover_sweep': + stage=event['stage'];blocks[stage]=[] + need(stage is not None,'event before first call') + blocks[stage].append(event) + progression=[0]*74;last={};result={} + for t,(stage,replica) in enumerate(order): + need(0<=replica<74 and stage==progression[replica],'order chronology') + progression[replica]+=1 + for j,event in enumerate(blocks[stage]): + kind=event['kind'] + if kind=='local_cover_sweep': + need(j==0,'local call position') + last[replica,pairs[stage]]=t + elif kind=='bridge': + last[replica,event['src']]=last[replica,event['dst']]=t + elif kind=='idle_cover_sweep': + need(j>0,'idle position') + start=last.get((replica,event['pair']),-1) + for child in event['child_indices']: + if child in ranks: + result[replica,child]=(ranks[child],start,t) + need(progression==[9]*74,'complete replica progression') + return result + + +def check(plan, template, order, fill, providers, initial_dispatch, expected_profile): + need(len(order)==666 and len(set(map(tuple,order)))==666,'call coverage') + win=windows(template,order) + dispatch=dict(initial_dispatch) + for s,r,pid in fill['dispatch_overrides']: + need((s,r) in dispatch and pid in providers,'dispatch override') + dispatch[s,r]=pid + need(set(dispatch)==set(map(tuple,order)),'dispatch coverage') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns') + R=len(next(iter(providers.values()))['widths']) # retired5: helper count from the providers (was 415) + need(len(fill['rows'])==666*R,'role count') + need(all(len(p['widths'])==R for p in providers.values()),'helper widths') + helper_bits=[0]*666;family_bits=[0]*666;occupied={} + for row in fill['rows']: + need(len(row)==6 and all(type(v) is int for v in row),'role shape') + t,h,o,c,port,offset=row + need(0<=t<666 and 0<=h 5, the exact propagated floor) and raises each follower's first gate (606, 635, 637, 638, 639: dim 4 -> 5, the exact ceiling), with their meet/join closures; gates unchanged", + "frames": [ + [ + "B", + 901, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 902, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 903, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 909, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 910, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "B", + 947, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 948, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 949, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 951, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 952, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1024, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1025, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1026, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1027, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1028, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1029, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1030, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1031, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1032, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1033, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1034, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1035, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1040, + [ + 257, + 129, + 67, + 37, + 17, + 15 + ] + ], + [ + "B", + 1041, + [ + 257, + 129, + 68, + 34, + 22, + 8 + ] + ], + [ + "B", + 1042, + [ + 257, + 129, + 76, + 40, + 28, + 2 + ] + ], + [ + "B", + 1043, + [ + 257, + 129, + 73, + 42, + 27, + 5 + ] + ] + ], + "local_profile": { + "1": 2401, + "2": 639, + "3": 278, + "4": 129, + "5": 26, + "8": 8 + }, + "refit_log": [ + { + "h": 606, + "L": 550, + "lowered": [ + [ + 11940, + 6, + 5 + ] + ], + "raised": [ + [ + 11993, + 4, + 5 + ], + [ + 11994, + 4, + 5 + ], + [ + 11995, + 4, + 5 + ], + [ + 11997, + 4, + 5 + ], + [ + 11998, + 4, + 5 + ] + ] + }, + { + "h": 635, + "L": 551, + "lowered": [ + [ + 11941, + 6, + 5 + ] + ], + "raised": [ + [ + 12082, + 4, + 5 + ], + [ + 12083, + 4, + 5 + ], + [ + 12084, + 4, + 5 + ], + [ + 12085, + 4, + 5 + ], + [ + 12086, + 4, + 5 + ], + [ + 12087, + 4, + 5 + ], + [ + 12088, + 4, + 5 + ], + [ + 12089, + 4, + 5 + ], + [ + 12090, + 4, + 5 + ], + [ + 12091, + 4, + 5 + ], + [ + 12092, + 4, + 5 + ], + [ + 12093, + 4, + 5 + ], + [ + 12098, + 5, + 6 + ], + [ + 12099, + 5, + 6 + ], + [ + 12100, + 5, + 6 + ], + [ + 12101, + 5, + 6 + ] + ] + }, + { + "h": 637, + "L": 552, + "lowered": [ + [ + 11948, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 638, + "L": 553, + "lowered": [ + [ + 11949, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 639, + "L": 562, + "lowered": [ + [ + 11942, + 6, + 5 + ] + ], + "raised": [] + } + ] +} diff --git a/research/t74-joint-twelve-retired7/inputs/refit5_43extra.json b/research/t74-joint-twelve-retired7/inputs/refit5_43extra.json new file mode 100644 index 0000000000..73fa6c445a --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit5_43extra.json @@ -0,0 +1,473 @@ +{ + "kind": "FRAME_REFIT_FOR_FIVE_ALIASES", + "credit": "exact minimal-change frame refit for the five retired-lender aliases (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): new/borrow/refit/search lowers each lender's last gate (550, 551, 552, 553, 562: dim 6 -> 5, the exact propagated floor) and raises each follower's first gate (606, 635, 637, 638, 639: dim 4 -> 5, the exact ceiling), with their meet/join closures; gates unchanged", + "frames": [ + [ + "B", + 901, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 902, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 903, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 909, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 910, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "B", + 947, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 948, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 949, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 951, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 952, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1024, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1025, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1026, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1027, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1028, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1029, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1030, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1031, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1032, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1033, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1034, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1035, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1040, + [ + 257, + 129, + 67, + 37, + 17, + 15 + ] + ], + [ + "B", + 1041, + [ + 257, + 129, + 68, + 34, + 22, + 8 + ] + ], + [ + "B", + 1042, + [ + 257, + 129, + 76, + 40, + 28, + 2 + ] + ], + [ + "B", + 1043, + [ + 257, + 129, + 73, + 42, + 27, + 5 + ] + ] + ], + "local_profile": { + "1": 2401, + "2": 639, + "3": 278, + "4": 129, + "5": 26, + "8": 8 + }, + "refit_log": [ + { + "h": 606, + "L": 550, + "lowered": [ + [ + 11940, + 6, + 5 + ] + ], + "raised": [ + [ + 11993, + 4, + 5 + ], + [ + 11994, + 4, + 5 + ], + [ + 11995, + 4, + 5 + ], + [ + 11997, + 4, + 5 + ], + [ + 11998, + 4, + 5 + ] + ] + }, + { + "h": 635, + "L": 551, + "lowered": [ + [ + 11941, + 6, + 5 + ] + ], + "raised": [ + [ + 12082, + 4, + 5 + ], + [ + 12083, + 4, + 5 + ], + [ + 12084, + 4, + 5 + ], + [ + 12085, + 4, + 5 + ], + [ + 12086, + 4, + 5 + ], + [ + 12087, + 4, + 5 + ], + [ + 12088, + 4, + 5 + ], + [ + 12089, + 4, + 5 + ], + [ + 12090, + 4, + 5 + ], + [ + 12091, + 4, + 5 + ], + [ + 12092, + 4, + 5 + ], + [ + 12093, + 4, + 5 + ], + [ + 12098, + 5, + 6 + ], + [ + 12099, + 5, + 6 + ], + [ + 12100, + 5, + 6 + ], + [ + 12101, + 5, + 6 + ] + ] + }, + { + "h": 637, + "L": 552, + "lowered": [ + [ + 11948, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 638, + "L": 553, + "lowered": [ + [ + 11949, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 639, + "L": 562, + "lowered": [ + [ + 11942, + 6, + 5 + ] + ], + "raised": [] + } + ] +} diff --git a/research/t74-joint-twelve-retired7/inputs/refit5c_43base.json b/research/t74-joint-twelve-retired7/inputs/refit5c_43base.json new file mode 100644 index 0000000000..6779edb0aa --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit5c_43base.json @@ -0,0 +1,297 @@ +{ + "kind": "FRAME_REFIT_CERTIFIED_OPTIMAL_ALIASED", + "credit": "certified optimal frames of the aliased program (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): our #1186 toolkit optimal_frames on the borrow-word model of new/borrow/audit_local.py; gates, warps, start/final frames, compensation and widths unchanged", + "frames": [ + [ + "A", + 0, + [] + ], + [ + "A", + 1, + [] + ], + [ + "A", + 2, + [] + ], + [ + "A", + 3, + [] + ], + [ + "A", + 4, + [] + ], + [ + "A", + 5, + [] + ], + [ + "A", + 6, + [] + ], + [ + "A", + 7, + [] + ], + [ + "A", + 8, + [] + ], + [ + "A", + 9, + [] + ], + [ + "A", + 10, + [] + ], + [ + "A", + 11, + [] + ], + [ + "B", + 771, + [ + 392, + 64, + 33, + 17, + 3 + ] + ], + [ + "B", + 773, + [ + 395, + 64, + 33, + 18, + 4 + ] + ], + [ + "B", + 776, + [ + 259, + 132, + 76, + 33, + 18 + ] + ], + [ + "B", + 778, + [ + 260, + 131, + 76, + 33, + 18 + ] + ], + [ + "B", + 783, + [ + 390, + 65, + 33, + 19, + 13 + ] + ], + [ + "B", + 788, + [ + 257, + 134, + 64, + 33, + 30 + ] + ], + [ + "B", + 941, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 942, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 943, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 944, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 945, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 946, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 950, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1148, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 1149, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 1150, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 1151, + [ + 259, + 148, + 66, + 36, + 9 + ] + ], + [ + "B", + 1168, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 1169, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "restore", + 60, + [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + ] + ], + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } +} diff --git a/research/t74-joint-twelve-retired7/inputs/refit5c_43extra.json b/research/t74-joint-twelve-retired7/inputs/refit5c_43extra.json new file mode 100644 index 0000000000..6779edb0aa --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit5c_43extra.json @@ -0,0 +1,297 @@ +{ + "kind": "FRAME_REFIT_CERTIFIED_OPTIMAL_ALIASED", + "credit": "certified optimal frames of the aliased program (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): our #1186 toolkit optimal_frames on the borrow-word model of new/borrow/audit_local.py; gates, warps, start/final frames, compensation and widths unchanged", + "frames": [ + [ + "A", + 0, + [] + ], + [ + "A", + 1, + [] + ], + [ + "A", + 2, + [] + ], + [ + "A", + 3, + [] + ], + [ + "A", + 4, + [] + ], + [ + "A", + 5, + [] + ], + [ + "A", + 6, + [] + ], + [ + "A", + 7, + [] + ], + [ + "A", + 8, + [] + ], + [ + "A", + 9, + [] + ], + [ + "A", + 10, + [] + ], + [ + "A", + 11, + [] + ], + [ + "B", + 771, + [ + 392, + 64, + 33, + 17, + 3 + ] + ], + [ + "B", + 773, + [ + 395, + 64, + 33, + 18, + 4 + ] + ], + [ + "B", + 776, + [ + 259, + 132, + 76, + 33, + 18 + ] + ], + [ + "B", + 778, + [ + 260, + 131, + 76, + 33, + 18 + ] + ], + [ + "B", + 783, + [ + 390, + 65, + 33, + 19, + 13 + ] + ], + [ + "B", + 788, + [ + 257, + 134, + 64, + 33, + 30 + ] + ], + [ + "B", + 941, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 942, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 943, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 944, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 945, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 946, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 950, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1148, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 1149, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 1150, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 1151, + [ + 259, + 148, + 66, + 36, + 9 + ] + ], + [ + "B", + 1168, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 1169, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "restore", + 60, + [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + ] + ], + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } +} diff --git a/research/t74-joint-twelve-retired7/inputs/refit7_43base.json b/research/t74-joint-twelve-retired7/inputs/refit7_43base.json new file mode 100644 index 0000000000..0095915f00 --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit7_43base.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_FOR_TWO_HOSTEE_MOVES","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): new/borrow/refit/search lowers the last gates of the free retired lenders 564 (B911) and 565 (B912) from dim 6 to their exact propagated floor dim 5 (meet closure: no other gate changes); gates unchanged","frames":[["B",911,[258,130,84,44,1]],["B",912,[258,130,74,45,31]]],"local_profile":{"1":2388,"2":646,"3":268,"4":130,"5":26,"8":8},"previous_frames":[["B",911,[258,130,76,44,24,1]],["B",912,[258,130,74,43,25,6]]]} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/inputs/refit7_43extra.json b/research/t74-joint-twelve-retired7/inputs/refit7_43extra.json new file mode 100644 index 0000000000..0095915f00 --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit7_43extra.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_FOR_TWO_HOSTEE_MOVES","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): new/borrow/refit/search lowers the last gates of the free retired lenders 564 (B911) and 565 (B912) from dim 6 to their exact propagated floor dim 5 (meet closure: no other gate changes); gates unchanged","frames":[["B",911,[258,130,84,44,1]],["B",912,[258,130,74,45,31]]],"local_profile":{"1":2388,"2":646,"3":268,"4":130,"5":26,"8":8},"previous_frames":[["B",911,[258,130,76,44,24,1]],["B",912,[258,130,74,43,25,6]]]} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/inputs/refit7c_43base.json b/research/t74-joint-twelve-retired7/inputs/refit7c_43base.json new file mode 100644 index 0000000000..acd4d17dc2 --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit7c_43base.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_CERTIFIED_OPTIMAL_RETIRED7","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): certified optimal frames of the aliased program (our #1186 toolkit optimal_frames on the borrow-word model, certified=True); gates, warps, start/final frames, compensation and widths unchanged","frames":[["B",1170,[258,130,84,44,1]],["B",1171,[258,130,74,45,31]]],"local_profile":{"1":2382,"2":648,"3":268,"4":128,"5":26,"8":8}} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/inputs/refit7c_43extra.json b/research/t74-joint-twelve-retired7/inputs/refit7c_43extra.json new file mode 100644 index 0000000000..acd4d17dc2 --- /dev/null +++ b/research/t74-joint-twelve-retired7/inputs/refit7c_43extra.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_CERTIFIED_OPTIMAL_RETIRED7","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): certified optimal frames of the aliased program (our #1186 toolkit optimal_frames on the borrow-word model, certified=True); gates, warps, start/final frames, compensation and widths unchanged","frames":[["B",1170,[258,130,84,44,1]],["B",1171,[258,130,74,45,31]]],"local_profile":{"1":2382,"2":648,"3":268,"4":128,"5":26,"8":8}} \ No newline at end of file diff --git a/research/t74-joint-twelve-retired7/joint_engine.py b/research/t74-joint-twelve-retired7/joint_engine.py new file mode 100644 index 0000000000..e76585f43f --- /dev/null +++ b/research/t74-joint-twelve-retired7/joint_engine.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Restore retired source pairs before handoff; generate twelve joint aliases. + +Derived from PR2462 (Jeremy Kothe), PR2436 lifted-target work (Tekalign), +and PR2322 generator utilities (Vlado Vojdanovski), all with AI assistance. +This derivative: OpenAI Codex at the user's direction. See README for scope. +""" +import sys,json,gzip,copy,importlib.util +from pathlib import Path +from fractions import Fraction as Q +from collections import defaultdict,Counter +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE/'vendor')) +import generate_words as G +import gf_chart as C +from target_transport import step + +def mod(name,path): + spec=importlib.util.spec_from_file_location(name,path);module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);return module + +def paid_lifted(w): + src=Path(G.__file__).read_text();src=src[src.index('def paid_profile('):src.index('\ndef build(')] + src=src.replace("for event in word['A']:\n gate(event)","""for event in word['A']: + if event[0]=='warp': + _,r,op,U,V=event + cols=word['warps'][abs(op)-1][2] + if op<0: + back={mapped(cols,x):x for x in range(512)};cols=[back[1<len(a):a.append(x) + for x in F: + if len(b)len(b):b.append(x) + assert len(a)==len(b)==4 + cols=C.gf_change(a,b,9);E=[C.gf_linear(cols,x) for x in U] if hasattr(C,'gf_linear') else [G.mapped(cols,x) for x in U] + op=len(w['warps'])+len(newrecords)+1;newrecords.append([first,r,cols,list(U),E]);replace[h]=r + nw['removed'].append(h);del nw['start_extra'][str(h)];nw['helper_final'].pop(str(h),None) + # Keep preexisting operator IDs stable; extra warps are appended to the table. + newB=[];position={} + for i in range(len(w['B'])+1): + newB.extend(before[i]);position[i]=len(newB) + if ilen(w['warps']),(t,r,op,q) + groups[r,op[0]][t]=-q + prelude=[];targetlines={} + for (r,op),coeff in groups.items(): + for g in nw['precondition']+nw['compensation']:coeff=step(coeff,g,set(range(112,224))) + record=nw['warps'][op-1];line=[G.mapped(record[2],w['ports'][r])] + for t in coeff: + assert t not in targetlines or targetlines[t]==line,(t,r,op,line,targetlines.get(t),dict(groups)) + targetlines[t]=line + prelude.append(['warp',r,op,[w['ports'][r]],line]) + for t,q in sorted(coeff.items()):prelude.append(['add',t,r,q.numerator,q.denominator,line]) + prelude.append(['warp',r,-op,line,[w['ports'][r]]]) + lifts=[] + for t,line in sorted(targetlines.items()): + key=str(t-112);old=nw['target_levels'].get(key,[]);assert not old or G.basis(old)==G.basis(line) + if not old:lifts.append(['scale',t,1,1,line]);nw['target_levels'][key]=line + nw['A']=lifts+prelude+nw['A'];nw['prelude_events']+=len(lifts)+len(prelude) + tmp=copy.deepcopy(nw);tmp['A']=tmp['A'][nw['prelude_events']:];nw['cleanup']=WP.derive_cleanup(tmp,WP.restored_of(w)) + pp,iv=paid_lifted(nw);nw['report']['local_profile']=pp;nw['report']['width_inventory']=iv + out=BASE/f'eight-alias-{tag}.json.gz';out.write_bytes(gzip.compress(json.dumps(nw,separators=(',',':')).encode())) + print('BUILT',tag,'newops',len(newrecords),'targets',targetlines,'file',out,flush=True) + AU2.run(out,BASE/f'eight-alias-{tag}-audit.json') + return nw diff --git a/research/t74-joint-twelve-retired7/packing_cap.py b/research/t74-joint-twelve-retired7/packing_cap.py new file mode 100644 index 0000000000..fe937f8667 --- /dev/null +++ b/research/t74-joint-twelve-retired7/packing_cap.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Uses Douglas Colkitt's exact ceiling engine (Claude-assisted), pinned unchanged. +# Adapter by Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Fixed-word coverage-law ceiling; separate from physical and outer admission.""" +import argparse, hashlib, importlib.util, json, sys +from fractions import Fraction as Q +from decimal import Decimal, localcontext +from pathlib import Path +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +IDLE = {1:17316,3:6594,5:9878,32:1,48:26558} +CANDIDATE = {1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} +ENDPOINT = Q('0.001717794984118634663827') + +def need(ok, message): + if not ok: + raise ValueError(message) + +def calculate(profile_path=None): + path = HERE / 'vendor/ceiling.py' + need(hashlib.sha256(path.read_bytes()).hexdigest() == ENGINE_SHA, 'ceiling source pin') + spec = importlib.util.spec_from_file_location('packing_ceiling', path) + engine = importlib.util.module_from_spec(spec); spec.loader.exec_module(engine) + h = {int(r): n for r,n in json.loads((profile_path or HERE/'PROFILE.json').read_text()).items()} + need(h == CANDIDATE and sum(r*n for r,n in h.items()) == 4816512, + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} + need(local == {1:2382,2:648,3:268,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) + need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5188, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') + c = Q(json.loads((HERE/'CLAIM.json').read_text())['complex_lower']) + need(c == ENDPOINT, 'certified candidate endpoint') + with localcontext() as ctx: + ctx.prec = 50 + dec = lambda x: str(Decimal(x.numerator)/Decimal(x.denominator)) + return dict(status='PASS_FIXED_WORD_PACKING_CEILING',source_sha256=ENGINE_SHA, + local_per_call={str(r):str(n) for r,n in local.items()}, + dimension=73,families=896,stages=9,centre_rank_per_call=64,max_idle_rank=model['R'], + complex_cap_bracket=[str(lo),str(hi)],complex_cap_upper_decimal=dec(hi), + realized_fraction_lower=str(c/hi),realized_fraction_decimal=dec(c/hi), + scope='Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used.') + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--output',type=Path) + ap.add_argument('--profile',type=Path,default=HERE/'PROFILE.json');a=ap.parse_args() + text=json.dumps(calculate(a.profile),indent=2)+'\n' + if a.output: + a.output.parent.mkdir(parents=True,exist_ok=True);a.output.write_text(text) + print(text,end='') +if __name__=='__main__': main() diff --git a/research/t74-joint-twelve-retired7/requirements.txt b/research/t74-joint-twelve-retired7/requirements.txt new file mode 100644 index 0000000000..816d0c8e91 --- /dev/null +++ b/research/t74-joint-twelve-retired7/requirements.txt @@ -0,0 +1,4 @@ +numpy==2.5.4 +sympy==1.14.0 +scipy==1.18.1 +mpmath==1.3.0 diff --git a/research/t74-joint-twelve-retired7/retired7_controls.py b/research/t74-joint-twelve-retired7/retired7_controls.py new file mode 100644 index 0000000000..67a9818ac7 --- /dev/null +++ b/research/t74-joint-twelve-retired7/retired7_controls.py @@ -0,0 +1,73 @@ +# SPDX-License-Identifier: Apache-2.0 +# Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +"""retired7 tamper controls on a final BORROW-WORD (each mutant gets its inverse-reverse cleanup re-derived from its own forward +word; a rejection by a stale-cleanup/operator-id reason counts as a FAILURE): + refit7: each new lender's last-gate refit undone must be rejected by 'warp frame mismatch'; + hostmove2: per moved hostee - warp lender reverted, move undone (hostee back on its old lender, which now hosts the new alias), + warp before the new lender retires, G wrong; + alias7 (the PR2679 alias suite per new alias): borrowed read sign flipped, read doubled, write sign flipped, warp dropped, + G wrong, warp after the follower's first gate (the lender's own life ended in A, so 'before retirement' has no B position), + helper kept with an entrance frame; + refit7c: one certified frame corrupted. +usage: retired7_controls.py WORD INPUT_DIR TAG OUT (INPUT_DIR holds refit7/hostmove2/alias7/refit7c_43TAG.json; audit_local.py and +word_patch.py are imported from this directory)""" +import copy, contextlib, gzip, io, json, sys, tempfile +from pathlib import Path +VACUOUS = ('explicit cleanup differs', 'warp operator id') +def regs(e): return e[1:3] if e[0] == 'add' else e[1:2] +def relabel(m, start, a, b): + for i in range(start, len(m['B'])): + e = m['B'][i] + if e[0] == 'add': + if e[1] == a: e[1] = b + if e[2] == a: e[2] = b + elif e[1] == a: e[1] = b +def controls(w0, p7, ph, pa, pc, audit, WP): + """audit(word) -> None (accepted) or the rejection reason; returns (all_ok, results)""" + def rederive(m): + m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(w0)); m2['A'] = A; return m2 + res = {} + def expect(name, m, reason=None, fresh=True): + r = audit(rederive(m) if fresh else m) + ok = r is not None and not r.split(': ', 1)[-1].startswith(VACUOUS) and (reason is None or reason in r) + res[name] = dict(rejected=r is not None, reason=(r or '')[:160], real_reason=ok) + need = audit(w0); assert need is None, ('unmutated final word rejected', need) + for sec, i, fr in p7['previous_frames']: + m = copy.deepcopy(w0); m[sec][i][-1] = fr; expect(f'refit7 {sec}{i} lender refit undone', m, 'warp frame mismatch') + for mv in ph['moves']: + k = mv['op'] - 1; tag = f"move{mv['op']} {mv['L_old']}->{mv['L_new']}" + m = copy.deepcopy(w0); m['warps'][k][1] = mv['L_old']; expect(tag + ' warp lender reverted', m) + m = copy.deepcopy(w0); m['warps'][k] = copy.deepcopy(mv['old_record']); relabel(m, mv['old_pos'], mv['L_new'], mv['L_old']); expect(tag + ' move undone', m) + m = copy.deepcopy(w0); m['warps'][k][0] = mv['pos'] - 400; expect(tag + ' warp before lender retirement', m) + m = copy.deepcopy(w0); m['warps'][k][2][0] ^= m['warps'][k][2][1]; expect(tag + ' G wrong', m) + for a in pa['aliases']: + h, L = a['h'], a['L']; op = next(i for i, r in enumerate(w0['warps']) if r[1] == L and r[0] == a['pos']); tag = f'{h}<-{L}' + reads = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] + writes = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] + m = copy.deepcopy(w0); m['B'][reads[0]][3] *= -1; expect(tag + ' borrowed read sign flipped', m) + m = copy.deepcopy(w0); m['B'][reads[0]][3] *= 2; expect(tag + ' borrowed read doubled', m) + if writes: m = copy.deepcopy(w0); m['B'][writes[0]][3] *= -1; expect(tag + ' borrowed write sign flipped', m) + m = copy.deepcopy(w0); del m['warps'][op] + for e in m['A'][:m['prelude_events']]: + if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 + expect(tag + ' warp dropped', m) + m = copy.deepcopy(w0); m['warps'][op][2][0] ^= m['warps'][op][2][1]; expect(tag + ' G wrong', m) + m = copy.deepcopy(w0); m['warps'][op][0] = a['pos'] + 1; expect(tag + " warp after the follower's first gate", m) + m = copy.deepcopy(w0); m['start_extra'][str(h)] = a['E']; expect(f'{h} kept with an entrance frame', m) + sec, i, fr = pc['frames'][0]; m = copy.deepcopy(w0); m[sec][i][-1] = [1]; expect('refit7c certified frame corrupted', m, fresh=False) + return all(r['real_reason'] for r in res.values()), res +if __name__ == '__main__': + here = Path(__file__).resolve().parent; sys.path.insert(0, str(here)) + import audit_local as al, word_patch as WP + w0 = json.loads(gzip.decompress(Path(sys.argv[1]).read_bytes())); D = Path(sys.argv[2]); tag = sys.argv[3]; tmp = Path(tempfile.mkdtemp()) + p = {n: json.loads((D / f'{n}_43{tag}.json').read_text()) for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')} + def audit(w): + q = tmp / 'm.json.gz'; q.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode())) + try: + with contextlib.redirect_stdout(io.StringIO()): al.run(q, tmp / 'm.out.json', None, None) + return None + except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as e: + return (type(e).__name__ + ': ' + str(e))[:200] + ok, res = controls(w0, p['refit7'], p['hostmove2'], p['alias7'], p['refit7c'], audit, WP) + Path(sys.argv[4]).write_text(json.dumps(dict(all_rejected_for_real_reasons=ok, controls=res), indent=1) + '\n') + print(('ALL RETIRED7 CONTROLS REJECTED' if ok else 'RETIRED7 CONTROL FAILURE'), sum(r['real_reason'] for r in res.values()), 'of', len(res)); sys.exit(0 if ok else 1) diff --git a/research/t74-joint-twelve-retired7/test_integrity.py b/research/t74-joint-twelve-retired7/test_integrity.py new file mode 100644 index 0000000000..eedb99e86a --- /dev/null +++ b/research/t74-joint-twelve-retired7/test_integrity.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Git-free read-only replay and fail-closed input/claim/optimization controls.""" +import hashlib,json,os,shutil,subprocess,sys,tempfile +from pathlib import Path +HERE=Path(__file__).resolve().parent +def need(ok,msg): + if not ok:raise RuntimeError(msg) +def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} +def main(): + with tempfile.TemporaryDirectory(prefix='joint-twelve-retired7-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) + r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') + f=p/'CLAIM.json';b=f.read_bytes();c=json.loads(b);c['kappa']='1';f.write_text(json.dumps(c));r=run();need(r.returncode!=0 and 'claim outer endpoint' in r.stderr,'claim corruption rejection');f.write_bytes(b) + f=p/'inputs/WORD-base.json.gz';b=f.read_bytes();f.write_bytes(b+b'corruption');r=run();need(r.returncode!=0 and 'input digest' in r.stderr,'word authentication rejection');f.write_bytes(b) + need(hashes(p)==before,'controls restore exact files') + print('PASS_JOINT_TWELVE_RELOCATED_READ_ONLY_AND_INTEGRITY_CONTROLS') +if __name__=='__main__':main() diff --git a/research/t74-joint-twelve-retired7/vendor/GENERATOR-NOTICE.txt b/research/t74-joint-twelve-retired7/vendor/GENERATOR-NOTICE.txt new file mode 100644 index 0000000000..b075f7180e --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/GENERATOR-NOTICE.txt @@ -0,0 +1,129 @@ +Generator for PR2312 width exchange plus coherent four-handoff transformation +========================================================================== + +generate_words.py is new portable code prepared with substantial AI +assistance, under the repository Apache-2.0 license. It directly transforms +the pinned PR2312 width-exchange BORROW-WORDs and regenerates cleanup. The existing source +builder is not copied or imported at runtime. The independent native chain, +rather than the generator or its hashes, proves all-column circuit correctness +and exact physical Clifford phases. + +PR2312 width exchange is credited to Jeremy Kothe (@jeremykothe2), with +AI assistance: alias 651 is re-lent from lender 530 and alias 653 is dropped, +freeing register 554 for cold restoration and changing two width-8 helpers +to width 7. The exact frame re-solve of both borrowed words and the owner +fill for that source width inventory retain the source's credit to Jeremy +Kothe, with AI assistance. This generator consumes the resulting complete +source words; it does not reapply their kernels or width exchange. + +Consumed PR2312 source head: + fb76f799ccf078f51780076ebed3fd26b1db11c0 +Package: + research/gmx-t74-borrow43-width-exchange +Manifest SHA-256: + c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313 + +The two helper-donor kernels at pivots 518 and 506 are retained from +PR2302. Their kernel shape is credited to mdumitrean (PR1625); their search, +exact pricing and frame re-solve are credited to Jeremy Kothe +(@jeremykothe2), with AI assistance, as stated by the source. The PR2302 +source and this necessary derivative generator were prepared with AI +assistance. This generator composes the four block-616 handoffs after those +kernels, preserving all kernel scalar gates and their re-solved frames. + +Predecessor PR2302 source head: + d520b92d7bf18efcb7d84f12757face6fe9541f1 +Package: + research/gmx-t74-borrow43-k518-506 +Manifest SHA-256: + 74634d13d27026e2867973b58dfef5e31958d92c54454b29e52292b7fc2e1f0d + +WildIdeas is credited for the exact frame refits retained from PR2288. +The source's additional frame-solver credit to Jeremy Kothe, with AI +assistance, is retained. The predecessor's full credit and licensing notice +is reproduced below. + +Anticipatory dirty borrowing is credited first to Cinna Davis +(@1337isnot1337), PR2226, with substantial OpenAI Codex assistance. The +retired-register K_G handoff and inverse-reverse FULL cleanup with proper-ended +private zero buffers derive from that construction and its PR2288 realization. +PR2288 source head: 614c74a63b0f6d4a24c7740d7ddb90d37861b3c7. + +This code is licensed under Apache-2.0, inherited from the repository. +The original repository LICENSE and NOTICE remain in the predecessor source; +the consumed package NOTICE is reproduced verbatim below, along with the +additional PR2226 notice. The PR2312 and PR2302 package NOTICE files are byte-identical to the +PR2288 package NOTICE reproduced here. + +--- PR2288 package NOTICE (verbatim) --- + +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. + + +--- PR2226 native-chain notice (verbatim) --- + +# Credit: anticipatory dirty borrowing (PR2226) + +The construction realised by this native chain is **PR2226, "anticipatory dirty borrowing"**, by Cinna Davis +(@1337isnot1337), prepared with substantial OpenAI Codex assistance (Apache-2.0): the logical reference change +K_G of a lender register (a monomial Clifford: a permutation of the 512 columns with phase mod 4), the initial +compensation terms c K_G z, the early cold tail, the exact cold restoration and the private zero buffers of the +FULL-frame cleanup. `vendor/pr2226_operators.py`, `vendor/pr2226_replay.py` and `vendor/PR2226-NOTICE.md` are byte copies +of PR2226's `operators.py`, `replay.py` and `NOTICE.md`. `bw_gauss.py` is a port of `operators.py` (change, monomial, +apply_mono, coord, frame, check) and adds a decoder from a serialized `clifford_exact` monomial to its exact 512 x 512 +Gaussian matrix. + +What this chain adds (the P3 native realisation, with the Borrow campaign's explicit chronological BORROW-WORD as input): +warp events and zero buffers in `LOCAL-PROGRAMS`, warp recipes in `CLIFFORD-RECIPES.json` (lowered with the unchanged +`lower_child`, rank zero, then compared with the exact numpy column product), logical K_G recipes in +`RESIDUAL-ADAPTERS.json`, an independent local replay in both orientations that checks every warp product on all 512 +columns, and the negative controls listed in `INDEPENDENT-LOCAL-REPLAY.json`, `WRAPPER-CHECKS.json`, `WARP-RECIPE-CHECKS.json` +and `bw_tamper.py`. + +Lineage retained: icekylinx (PR425/433/514, scalar and wrapper machinery), DreamingOfClouds (PR458/484/593 hyperplane/cold-HPE +extensions), the clifford_exact compiler (vendor531), and the owners named in the package README. `vendor/clifford/clifford_exact.py` +is a byte copy. + + +Reproduction and equality +======================== + +Run: + python3 generate_words.py --source-root FETCHED_REPOSITORY --out NEW_DIRECTORY + +The generator checks the pinned source manifest and both consumed compressed +source-word hashes. It writes base.json.gz, extra.json.gz and GENERATION.json. +Canonical JSON hashes cover every output field, including frames, scalar +gates, operators, endpoints, cleanup and invoices. These hashes determine +regenerated circuit equality. The compressed container hashes are recorded +for provenance; Python/zlib changes can produce different gzip streams for +the same circuit. The OS header byte is normalized to 255. In the recorded generation +environment both output containers also exactly match the composed +word hashes. Recompression alone does not require repeating native phases. + +The four binary G maps are explicit construction constants, checked for +invertibility and the measured source-to-handoff chart identity on each run. +The native replay independently lowers their exact physical representatives. +Two old warp-basis representatives are rewritten only after verifying equal +GF(2) spans, preserving the frozen input serialization. No JSON patch file or +unrecorded local dependency is needed. + +Composition binding +=================== + +The source-manifest and source-word constants bind the consumed PR2312 +inputs. The canonical JSON target hashes cover every composed output field. +The literal base tag names PR2312 width exchange plus coherent joint616; +SOURCE_COMMIT and SOURCE_MANIFEST identify the consumed source. +This generation receipt does not establish native phases, owner admission, +or a new exponent; those require their separate independently replayed +native and global receipts. diff --git a/research/t74-joint-twelve-retired7/vendor/LICENSE b/research/t74-joint-twelve-retired7/vendor/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/t74-joint-twelve-retired7/vendor/UPSTREAM-NOTICE b/research/t74-joint-twelve-retired7/vendor/UPSTREAM-NOTICE new file mode 100644 index 0000000000..46411b80b2 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/UPSTREAM-NOTICE @@ -0,0 +1,10 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. diff --git a/research/t74-joint-twelve-retired7/vendor/UPSTREAM-VENDOR-SOURCES.json b/research/t74-joint-twelve-retired7/vendor/UPSTREAM-VENDOR-SOURCES.json new file mode 100644 index 0000000000..cd19eda259 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/UPSTREAM-VENDOR-SOURCES.json @@ -0,0 +1,26 @@ +{ + "vendor/gf_chart.py": { + "sha256": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/census.py", + "mode": "four unchanged gf_* functions" + }, + "vendor/target_transport.py": { + "sha256": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/target_transport.py", + "mode": "unchanged full file" + }, + "vendor/generate_words.py": { + "sha256": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/generate_words.py", + "mode": "unchanged full file" + }, + "vendor/GENERATOR-NOTICE.txt": { + "sha256": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/GENERATOR-NOTICE.txt", + "mode": "unchanged full file" + } +} diff --git a/research/t74-joint-twelve-retired7/vendor/audit_local_pr2679.py b/research/t74-joint-twelve-retired7/vendor/audit_local_pr2679.py new file mode 100644 index 0000000000..8224873d04 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/audit_local_pr2679.py @@ -0,0 +1,501 @@ +"""Independent exact scalar/frame audit of the changed forward supplier. + +This does not import a generator, builder, stored compensation, or price. +All claimed endpoint matrices are derived from the input word's gates. +Optional --main checks the transported boundary against the pinned parent. +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. +""" +import argparse,gzip,json,hashlib,time +from pathlib import Path +from fractions import Fraction as F +from collections import Counter + +def require(x,label): + if not x:raise RuntimeError(label) + +def basis(vs): + piv={} + for a in vs: + while a: + bit=a.bit_length()-1 + if bit in piv:a^=piv[bit] + else: + piv[bit]=a;break + for k in sorted(piv): + for j in piv: + if j>k and piv[j]>>k&1:piv[j]^=piv[k] + return tuple(piv[k] for k in sorted(piv,reverse=True)) + +def contained(a,b):return basis(a+b)==b + +def registers(e):return e[1:3] if e[0]=='add' else e[1:2] + +def apply(e,rows,dual=False): + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + dst=rows[t] + for k,x in list(rows[s].items()): + a=dst.get(k,F(0))+q*x + if a:dst[k]=a + else:dst.pop(k,None) + elif e[0]=='scale': + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + else:raise RuntimeError('unknown scalar primitive') + +def invert(e): + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def check_parent_interface(word,main): + # Read only the retained boundary data. No builder or local checker is imported. + relative="research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz" + path=main/relative;raw=path.read_bytes() + require(hashlib.sha256(raw).hexdigest()=="66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",'parent canonical input pin') + parent=json.loads(gzip.decompress(raw)) + tau=lambda x:x^(43 if (x&43).bit_count()%2 else 0) + ports=parent['ports'];v=word['report']['v'] + require(len(ports)==len(set(ports))==v,'parent port count') + require(set(map(tau,word['ports']))==set(ports),'transported source/target ports') + moved={i:ports.index(tau(p)) for i,p in enumerate(word['ports'])} + centers=[moved.get(r,r) for r in word['centers']] + actual=[list(basis([tau(x) for x in frame])) for frame in word['center_frames']] + expected=[parent['frames'][f] for f in parent['center_frames']] + require(len(centers)==len(set(centers))==len(actual)==8,'eight distinct centre carriers') + require(actual==expected and all(len(f)==8 for f in actual),'ordered centre frame interface') + return dict(parent_path=relative,parent_file_sha256=hashlib.sha256(raw).hexdigest(), + transport_tau=43,ordered_frame_bases_match=True,all_ports_match=True, + transported_centers=centers,source_centers=[r for r in centers if r=2*v} + for e in w['precondition']:apply(e,dirt) + compensation=[['add',y,k,-a.numerator,a.denominator,[]] for y in range(v,2*v) for k,a in sorted(dirt[y].items())] + entering=set(map(int,w.get('start_extra',{})));lowends=set(map(int,w.get('helper_final',{}))) + coldends=lowends-entering + require(not any(e[2] in entering for e in compensation),'nonzero entrance response') + require(not any(r in entering|coldends for e in w['precondition']+compensation for r in registers(e)), 'pre-wrapper touch of residual helper') + require(all(e[-1]==[] for e in w['precondition']+compensation),'nonzero frame precondition') + early=w.get('early_cleanup',[]);earlyids={i for i,U in early} + require(len(earlyids)==len(early),'duplicate early cleanup gate') + tail=[w['cleanup'][i][:-1]+[U] for i,U in early] + cleanup=[e for i,e in enumerate(w['cleanup']) if i not in earlyids] + prefix=w['precondition']+compensation+main + program=prefix+tail+cleanup + for dual in (False,True): + actual=ident() + for e in program:apply(e,actual,dual) + expected=ident() + for t in range(v):expected[t if dual else v+t][v+t if dual else t]=F(-1 if dual else 1) + bad=[i for i in range(n) if actual[i]!=expected[i]] + require(not bad,'all-column endpoint failure '+str((dual,bad[:8]))) + print('endpoint', 'dual' if dual else 'forward','PASS',flush=True) + full=basis([1<>=1;i+=1 + return y + +def ginv(cols,h): + # inverse columns over F2 (None if singular), Gauss-Jordan on (G | I) column-wise + piv={}; + for i in range(h): + a=cols[i];b=1<>s&1:a^=piv[s][0];b^=piv[s][1] + if a:return None + pre.append(b) + return pre # pre[t] = G^{-1}(e_t) + +def gtrans(cols,h): + # transpose: column j of G^T = row j of G + return [sum(((cols[i]>>j)&1)< E (used for B-phase warps and for A-phase prelude warps)""" + inv=ginv(cols,h);require(inv is not None,'G not invertible') + require(all(gmul(cols,inv[t])==1<(Gx, (G+G^-T)x + G^-T z) + GiT=gtrans(inv,h) # G^{-T}: columns j = row j of G^{-1} + # G^{-T}(z): via columns GiT + def M(vec): + x=vec&((1<>h + gx=gmul(cols,x);S=gx^gmul(GiT,x) # (G + G^{-T}) x + return gx|((S^gmul(GiT,z))<>h)|((vec&((1<0)-(op<0))*(abs(op)+dsym)) + walg_add(rows[src],row,-c) + return + if e[0]=='warp': + op=e[2];s=(op>0)-(op<0) + if dual:op=s*(abs(op)+dsym) # dual orientation: K_G^{-T} is a distinct free symbol + rows[e[1]]=walg_warp(rows[e[1]],op);return + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + walg_add(rows[t],rows[s],q) + else: + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + +def invert_item(e,full): + if e[0]=='warp':return ['warp',e[1],-e[2]] + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def run_borrow(path,out,main,base,w,data,begin): + v,h,R=w['report']['v'],w['report']['h'],w['report']['R'];n=2*v+R + require((v,h)==(112,9),'wrong source geometry') + require(main is None,'--main parent interface is not available for coordinate-changed BORROW-WORD; use --base') + full=basis([1<=2*v,'correction source must be a remaining helper') + require(s not in entering,'correction source has nonzero entrance frame') + require(len(word)>=1 and all(1<=abs(o)<=K for o in word),'correction operator word') + require(c!=0 and c.denominator&(c.denominator-1)==0,'correction coefficient') + # the source is the lender of the operator it is read through + require(all(warps[abs(o)-1][1]==s for o in word),'correction source is not the lender of its operator') + # --- 4. frames: literal chain, monotone, paid profile --------------------------------------- + end=[full]*v+[basis([x for x in range(1,1<0 else list(to_),list(to_) if op_>0 else list(fr_),h) + require(cur[r_]==basis(fr_),'prelude warp frame mismatch '+str((r_,op_))) + cur[r_]=basis(to_) + else: + for q in registers(e):climb(q,e[-1]) + for e in Aord: + for q in registers(e):climb(q,e[-1]) + lev={int(t):basis(U) for t,U in w.get('target_levels',{}).items()} + require(all(cur[v+t]==lev.get(t,()) for t in range(v)),'target centre levels') + for q,U in zip(w['centers'],w['center_frames']): + U=basis(U);require(cur[q]==U,'center frame') + served={lev.get(e[1]-v,()) for e in w['cut'] if e[2]==q} + for T in sorted(served,key=lambda x:-len(x)): + require(contained(T,U),'center path not nested') + if T!=U:paid[len(U)-len(T)]+=1 + U=T + byposition={} + for op,rec in enumerate(warps,1):byposition.setdefault(rec[0],[]).append(op) + B=w['B'];forward=[] # chronological program of the (recorded) non-target word + for e in Aord:forward.append(e) + for p in range(len(B)+1): + for op in byposition.get(p,[]): + _,lender,cols,U,E=warps[op-1] + require(cur[lender]==basis(U),'warp frame mismatch '+str((op,lender,cur[lender],basis(U)))) + cur[lender]=basis(E);forward.append(['warp',lender,op]) + if p 1 is a what-if for a changed coverage law only); + * the local word fixes its own paid child profile `local` (per call); + * every remaining unit of mass is an idle/remainder child of rank at most R, where the outer + recipe's halving guard m^2 > 2 R^2 bounds R (R = 51 for m = 73). + +Lemma. For a >= 0, a child of rank r costs (r/m)^(1-a) = r * c(r), with c(r) = r^(-a) m^(a-1) +non-increasing in r. Hence, with idle mass M fixed and idle ranks <= R, every idle histogram has +moment >= the relaxation that puts all of M into (possibly fractional) rank-R children: + + relax(a) = [ sum_local n_r (r/m)^(1-a) + (M/R) (R/m)^(1-a) ] / w (per call). + +The moment is increasing in a. So relax(a*) > 1 certifies that no hosting, owner packing or +idle-remainder change of the given local word, template and outer recipe certifies a saving +>= a*. Under the retained reduction kappa < a/(1+a) when the complex side binds, so +a*/(1+a*) also bounds kappa. This is a bound for the stated model, not for other local words, +templates, coverage laws or outer recipes. + +Exact rational intervals: ln k from atanh chains, exp by Taylor with Lagrange remainder, +outward rounding to 2^-PREC. Standard library only. Douglas Colkitt, with Claude (Anthropic) +assistance. +""" +from fractions import Fraction as Q +from functools import lru_cache +from math import isqrt + +PREC = 256 + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def down(x): + return Q((x.numerator << PREC) // x.denominator, 1 << PREC) + + +def up(x): + return -down(-x) + + +@lru_cache(None) +def atanh(t): + """Enclosure of atanh(t) for rational 0 < t <= 1/3.""" + require(0 < t <= Q(1, 3), 'atanh range') + s, p, k = Q(0), t, 0 + while True: + term = p / (2 * k + 1) + s += term + p *= t * t + k += 1 + tail = p / ((2 * k + 1) * (1 - t * t)) + if tail < Q(1, 1 << (PREC + 8)): + return down(s), up(s + tail) + + +@lru_cache(None) +def ln(k): + """Enclosure of ln k for an integer k >= 1: ln k = ln(k-1) + 2 atanh(1/(2k-1)).""" + require(isinstance(k, int) and k >= 1, 'ln domain') + if k == 1: + return Q(0), Q(0) + lo, hi = ln(k - 1) + a, b = atanh(Q(1, 2 * k - 1)) + return down(lo + 2 * a), up(hi + 2 * b) + + +def exp(lo, hi): + """Enclosure of exp([lo, hi]) for 0 <= lo <= hi <= 1/2.""" + require(0 <= lo <= hi <= Q(1, 2), 'exp range') + def series(y, upper): + s, t, k = Q(1), Q(1), 0 + while True: + k += 1 + t = t * y / k + s += t + if t * y < Q(1, 1 << (PREC + 8)): + return up(s + 2 * t * y / (k + 1)) if upper else down(s) + return series(lo, False), series(hi, True) + + +def child_cost(r, m, a): + """Enclosure of (r/m)^(1-a) = (r/m) exp(a ln(m/r)).""" + lm, um = ln(m) + lr, ur = ln(r) + e = exp(max(Q(0), a * (lm - ur)), a * (um - lr)) + return down(Q(r, m) * e[0]), up(Q(r, m) * e[1]) + + +def max_idle_rank(m): + """Largest R with m^2 > 2 R^2 (outer halving guard).""" + R = isqrt((m * m - 1) // 2) + while 2 * (R + 1) ** 2 < m * m: + R += 1 + while 2 * R * R >= m * m: + R -= 1 + return R + + +def model(local, m, families, stages, centre, R=None, unpaid=1): + """Per-call quantities. local: {rank: count per call (Fraction ok)}.""" + R = max_idle_rank(m) if R is None else R + require(2 * R * R < m * m, 'idle rank cap violates the halving guard') + require(all(0 < r < m for r in local) and all(n >= 0 for n in local.values()), 'local profile') + w = Q(families, stages) + require(1 <= unpaid < m, 'unpaid coordinates per family') + total = (m - unpaid) * w + centre + local_mass = sum(r * Q(n) for r, n in local.items()) + idle = total - local_mass + require(idle >= 0, 'local word pays more mass than the coverage law allows') + return dict(R=R, w=w, total_mass=total, local_mass=local_mass, idle_mass=idle, deficit=unpaid * w - centre) + + +def relax(local, m, families, stages, centre, a, R=None, unpaid=1): + """Enclosure of the per-call relaxation moment at saving a.""" + q = model(local, m, families, stages, centre, R, unpaid) + lo = hi = Q(0) + for r, n in local.items(): + c = child_cost(r, m, a) + lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1] + c = child_cost(q['R'], m, a) + k = q['idle_mass'] / q['R'] + lo, hi = lo + k * c[0], hi + k * c[1] + return down(lo / q['w']), up(hi / q['w']) + + +def ceiling(local, m, families, stages, centre, grid=Q(1, 10 ** 15), R=None, unpaid=1): + """Grid bracket [a_lo, a_hi]: relax(a_lo) < 1 < relax(a_hi), certified. a_hi is the ceiling.""" + lo, hi = Q(0), Q(1, 20) + require(relax(local, m, families, stages, centre, hi, R, unpaid)[0] > 1, 'search window too small') + require(relax(local, m, families, stages, centre, lo, R, unpaid)[1] < 1, 'relaxation has no positive saving') + while hi - lo > grid: + mid = Q(int((lo + hi) / 2 / grid)) * grid + if mid <= lo: + mid = lo + grid + v = relax(local, m, families, stages, centre, mid, R, unpaid) + if v[1] < 1: + lo = mid + elif v[0] > 1: + hi = mid + else: + raise ValueError('enclosure too wide to separate the grid point') + return lo, hi diff --git a/research/t74-joint-twelve-retired7/vendor/generate_words.py b/research/t74-joint-twelve-retired7/vendor/generate_words.py new file mode 100644 index 0000000000..94bf0d8f29 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/generate_words.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Construct four coherent handoffs on the pinned PR2312 width-exchange words. + +This is a direct circuit transformation, using Python's standard library only. +It moves the twelve block-616 correction gates, replaces four retired helper +roles by the source lenders (1,4,6,12), installs their explicit invertible chart +maps, and derives inverse-reverse cleanup from the changed non-target word. +The source and resulting word content are hash-bound. Hash equality is a +reproduction check; the independent all-column native chain proves correctness. +The input retains PR2312's width exchange (alias 651 re-lent from 530 and +alias 653 dropped), exact frame re-solve and the pivot-518/506 kernels. +Width exchange and its source frame/owner work are credited to Jeremy Kothe +(jeremykothe2), with AI assistance. The helper-donor kernels retain credit: +PR1625 shape by mdumitrean; PR2302 search, exact pricing and frame re-solve +by Jeremy Kothe (jeremykothe2), with AI assistance. This derivative was also +prepared with substantial AI assistance. See GENERATOR-NOTICE.txt for +inherited attribution and licensing. +""" +import argparse +import copy +import gzip +import hashlib +import json +import platform +import zlib +from collections import Counter, defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PACKAGE = Path('research/gmx-t74-borrow43-width-exchange') +SOURCE_COMMIT = 'fb76f799ccf078f51780076ebed3fd26b1db11c0' +SOURCE_MANIFEST = 'c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313' +SOURCE_WORDS = { + 'base': '4244149b59b287344b0e91aa50c6fa2a2491ee6c7a76d61cd352684a8182d005', + 'extra': '01d510cc4ba912567f6b02ea50b6b0e741ed231a3608de9c36e7eeccbdaf6cda', +} +TARGET_WORDS = { + 'base': '93c32c9dc8ca18394b7f3afac2cb4fa8582a6cb77399441b5107b396e63ca0f9', + 'extra': 'aae6592eaa4cf8638f21d50c44d09d4f8a6bb079ddcf5e377711a10ee2ddb526', +} +TARGET_SEMANTICS = { + 'base': '3659c066d5cc2413a6f59bae8d5886e05feb8148333516f65365ad5235e14f2a', + 'extra': '9369702d158c34d594481a1789a2bddc029d03007253620cf3834ec60a88b1a5', +} +HIGH = (619, 621, 622, 623) +LOW = (616, 617, 618, 620) +LENDERS = (1, 4, 6, 12) +COMMON5 = (260, 132, 75, 42, 25) +COMMON4 = (260, 132, 75, 51) +# Literal G(e_i) columns of the four new rank-zero K_G handoffs. Each map is +# independently checked below, then physically lowered by the native auditor. +G_COLUMNS = ( + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 16, 32, 64, 135, 263), + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 57, 66, 143, 16, 272), +) +PROFILE = {1: 2335, 2: 512, 3: 426, 4: 120, 5: 38, 8: 8} +WIDTHS = {4: 33, 5: 9, 7: 38, 8: 114, 9: 240} + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def semantic_sha(value): + # JSON object keys are strings; normalize integer invoice keys before sorting. + value = json.loads(json.dumps(value)) + return sha(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()) + + +def basis(vectors): + """Canonical reduced GF(2) row basis, independent of set iteration order.""" + piv = {} + for value in vectors: + while value: + bit = value.bit_length() - 1 + if bit in piv: + value ^= piv[bit] + else: + piv[bit] = value + break + for bit in sorted(piv): + for higher in piv: + if higher > bit and (piv[higher] >> bit) & 1: + piv[higher] ^= piv[bit] + return tuple(piv[bit] for bit in sorted(piv, reverse=True)) + + +def incident(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def mapped(columns, vector): + result = 0 + for bit, column in enumerate(columns): + if (vector >> bit) & 1: + result ^= column + return result + + +def derive_cleanup(word): + """PR2226/PR2288 inverse-reverse cleanup, retaining proper-end buffers.""" + v = word['report']['v'] + n = 2 * v + word['report']['R'] + restored = set(map(int, word['helper_final'])) + full = list(basis(1 << bit for bit in range(word['report']['h']))) + buffer = lambda role: role + n if role in restored else role + by_position = defaultdict(list) + for operator, record in enumerate(word['warps'], 1): + by_position[record[0]].append((record[1], operator)) + forward = list(word['A']) + for position in range(len(word['B']) + 1): + forward.extend(['warp', role, operator] + for role, operator in by_position[position]) + if position < len(word['B']): + forward.append(word['B'][position]) + forward += word['restore'] + cleanup = [] + for gate in reversed(forward): + if gate[0] == 'warp': + cleanup.append(['warp', buffer(gate[1]), -gate[2], full]) + elif not v <= gate[1] < 2 * v: + if gate[0] == 'add': + cleanup.append(['add', buffer(gate[1]), buffer(gate[2]), + -gate[3], gate[4], full]) + else: + cleanup.append(['scale', buffer(gate[1]), gate[3], gate[2], full]) + return cleanup + + +def paid_profile(word): + """Recount literal native climbs, cut copies and retained helper widths.""" + v, h, helpers = (word['report'][key] for key in ('v', 'h', 'R')) + n = 2 * v + helpers + cur = [(port,) for port in word['ports']] + [()] * (v + helpers) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + full = basis(1 << bit for bit in range(h)) + ends = [full] * v + [basis(x for x in range(1, 1 << h) + if (x & port).bit_count() % 2 == 0) + for port in word['ports']] + [full] * helpers + for role, frame in word['helper_final'].items(): + ends[int(role)] = basis(frame) + paid = Counter() + + def climb(role, frame): + frame = basis(frame) + require(basis(cur[role] + frame) == frame, 'Nonmonotone frame chain') + degree = len(frame) - len(cur[role]) + if degree: + paid[degree] += 1 + cur[role] = frame + + def gate(event): + for role in incident(event): + climb(role, event[-1]) + + for event in word['A']: + gate(event) + levels = {int(t): basis(frame) for t, frame in word['target_levels'].items()} + require(all(cur[v+t] == levels.get(t, ()) for t in range(v)), 'Cut target frame') + for role, frame in zip(word['centers'], word['center_frames']): + frame = basis(frame) + require(cur[role] == frame, 'Cut producer frame') + readers = {levels.get(event[1]-v, ()) for event in word['cut'] + if event[2] == role} + for reader in sorted(readers, key=lambda x: -len(x)): + require(basis(reader + frame) == frame, 'Unnested private copy') + if reader != frame: + paid[len(frame)-len(reader)] += 1 + frame = reader + by_position = defaultdict(list) + for record in word['warps']: + by_position[record[0]].append(record) + for position in range(len(word['B']) + 1): + for _, role, columns, old, new in by_position[position]: + require(cur[role] == basis(old), 'Handoff source frame') + require(len(basis(columns)) == h, 'Singular chart map') + require(basis(mapped(columns, x) for x in old) == basis(new), + 'Chart map does not carry the measured source frame') + cur[role] = basis(new) + if position < len(word['B']): + gate(word['B'][position]) + for event in word['restore']: + gate(event) + live = set(range(n)) - set(word['removed']) + for role in live: + climb(role, ends[role]) + widths = Counter(len(ends[role]) - len(basis(word['start_extra'].get(str(role), []))) + for role in live if role >= 2 * v) + return dict(sorted(paid.items())), dict(sorted(widths.items())) + + +def build(source): + word = copy.deepcopy(source) + require(word['report']['v'] == 112 and word['report']['h'] == 9 + and word['report']['R'] == 480, 'Unexpected source geometry') + roles = set(LOW + HIGH) + prep = [i for i, event in enumerate(word['B']) + if set(incident(event)) <= roles] + # The only internal gates before source acquisition are the twelve M gates. + first = next(i for i, event in enumerate(word['B']) + if event[0] == 'add' and event[1] in roles + and event[2] not in roles and len(event[-1]) >= 6) + prep = [i for i in prep if i < first] + require(len(prep) == 12 and prep == list(range(prep[0], prep[0]+12)), + 'Expected twelve consecutive block-616 correction gates') + lo, hi = prep[0], prep[-1] + 1 + require(all(not roles.intersection(incident(event)) + for event in word['B'][hi:first]), 'Block is not idle before relocation') + require(all(basis(word['B'][i][-1]) == basis(COMMON5) for i in prep), + 'Unexpected correction chart') + require(all(event[0] == 'add' and event[1] in LOW and event[2] in HIGH + for event in (word['B'][i] for i in prep)), 'Unexpected correction payload') + require(all(basis(word['start_extra'][str(role)]) == basis(COMMON5) + for role in HIGH), 'Unexpected removed helper entrance') + require(not any(record[0] in range(lo, hi+1) or record[0] == first + for record in word['warps']), 'Warp inside relocation boundary') + replace = dict(zip(HIGH, LENDERS)) + moved = [event[:-1] + [list(COMMON4)] for event in word['B'][lo:hi]] + word['B'] = word['B'][:lo] + word['B'][hi:first] + moved + word['B'][first:] + handoff = first - len(moved) + for event in word['B']: + for index in range(1, 3 if event[0] == 'add' else 2): + event[index] = replace.get(event[index], event[index]) + for record in word['warps']: + if hi <= record[0] < first: + record[0] -= len(moved) + # Preserve the already-audited literal basis representatives emitted by + # the original builder. These replacements span precisely the same U. + rewrite = {(384, 134, 120, 30): (384, 134, 102, 30), + (448, 56, 21, 11): (448, 38, 21, 11)} + old = tuple(record[3]) + if old in rewrite: + require(basis(old) == basis(rewrite[old]), 'Basis serialization changed U') + record[3] = list(rewrite[old]) + # Measure each retired source at the chronological handoff, without trusting + # a lender chart copied from a generated target artifact. + cur = [(port,) for port in word['ports']] + [()] * (112 + 480) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + for event in source['A']: + for role in incident(event): + cur[role] = basis(event[-1]) + old_warps = defaultdict(list) + for record in source['warps']: + old_warps[record[0]].append(record) + for position in range(first): + for record in old_warps[position]: + cur[record[1]] = basis(record[4]) + for role in incident(source['B'][position]): + cur[role] = basis(source['B'][position][-1]) + for role, columns in zip(LENDERS, G_COLUMNS): + require(len(cur[role]) == 4, 'Retired lender must be rank 4') + require(max(i for i, event in enumerate(source['B']) + if role in incident(event)) < first, 'Source lender still live') + old_literal = (384, 131, 75, 51) if role == 4 else cur[role] + new_literal = (384, 132, 75, 51) + require(basis(old_literal) == cur[role] + and basis(new_literal) == basis(COMMON4), + 'Literal handoff representative changed its subspace') + word['warps'].append([handoff, role, list(columns), + list(old_literal), list(new_literal)]) + for role in HIGH: + del word['start_extra'][str(role)] + word['removed'] = sorted(set(word['removed']).union(HIGH)) + word['base'] = 'PR2312-width-exchange-plus-coherent-joint616' + profile, widths = paid_profile(word) + require(profile == PROFILE and widths == WIDTHS, 'Unexpected generated invoice') + word['report']['local_profile'] = profile + word['report']['width_inventory'] = widths + word['cleanup'] = derive_cleanup(word) + return word, dict(old_correction_interval=[lo, hi], old_first_input=first, + relocated_correction_interval=[handoff, handoff+12], + removed_roles=list(HIGH), lenders=list(LENDERS)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, required=True, + help='Repository root containing the pinned PR2312 package') + parser.add_argument('--out', '--output', type=Path, required=True, + help='Destination for base.json.gz, extra.json.gz and GENERATION.json') + args = parser.parse_args() + package = args.source_root.resolve() / PACKAGE + manifest_bytes = (package / 'MANIFEST.json').read_bytes() + require(sha(manifest_bytes) == SOURCE_MANIFEST, 'Unpinned upstream manifest') + manifest = json.loads(manifest_bytes) + args.out.mkdir(parents=True, exist_ok=True) + reports = {} + for kind in ('base', 'extra'): + relative = f'new/borrow/words/BORROW-WORD-43{kind}.json.gz' + raw = (package / relative).read_bytes() + require(sha(raw) == SOURCE_WORDS[kind] == manifest[relative], + 'Unpinned '+kind+' source word') + word, changes = build(json.loads(gzip.decompress(raw))) + content = json.dumps(word, separators=(',', ':')).encode() + canonical_hash = semantic_sha(word) + require(canonical_hash == TARGET_SEMANTICS[kind], + 'Generated '+kind+' circuit differs from the frozen audited input') + compressed = bytearray(gzip.compress(content, compresslevel=9, mtime=0)) + compressed[9] = 255 # Normalize the Python 3.11/3.12 gzip OS header byte. + compressed = bytes(compressed) + destination = args.out / (kind+'.json.gz') + destination.write_bytes(compressed) + reports[kind] = dict(source_word_sha256=sha(raw), output=destination.name, + output_sha256=sha(compressed), content_sha256=sha(content), + canonical_json_sha256=canonical_hash, + frozen_container_sha256=TARGET_WORDS[kind], + container_matches_frozen=sha(compressed) == TARGET_WORDS[kind], + local_profile=word['report']['local_profile'], + width_inventory=word['report']['width_inventory'], + changes=changes) + print('PASS_GENERATED_AUDITED_WORD_SEMANTICS', kind, canonical_hash, flush=True) + receipt = dict(status='PASS_SOURCE_BOUND_EXACT_WORD_GENERATION', + source_commit=SOURCE_COMMIT, source_manifest_sha256=SOURCE_MANIFEST, + generator_sha256=sha(Path(__file__).read_bytes()), words=reports, + compression_environment=dict(python=platform.python_version(), + zlib=zlib.ZLIB_RUNTIME_VERSION), + equality='Canonical JSON of every field; gzip container hashes are metadata', + scope='Exact source-bound reproduction of the independently audited words. ' + 'Circuit correctness, physical phases and the global owner invoice ' + 'are established by their separate native and global receipts.') + (args.out / 'GENERATION.json').write_text(json.dumps(receipt, indent=2)+'\n') + + +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve-retired7/vendor/gf_chart.py b/research/t74-joint-twelve-retired7/vendor/gf_chart.py new file mode 100644 index 0000000000..11f5bfd882 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/gf_chart.py @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +# Exact GF(2) chart utilities extracted from PR2436 census.py; unchanged functions. + +def gf_rank(xs): + b = {} + for x in xs: + while x: + j = x.bit_length() + if j not in b: + b[j] = x + break + x ^= b[j] + return len(b) + +def gf_extend(xs, h): + out = list(xs) + for j in range(h): + if gf_rank(out + [1 << j]) > len(out): + out.append(1 << j) + assert len(out) == h + return out + +def gf_linear(cols, x): + out = 0 + for j, c in enumerate(cols): + if x >> j & 1: + out ^= c + return out + +def gf_change(source, target, h): + a, b = gf_extend(source, h), gf_extend(target, h) + back = {gf_linear(a, x): x for x in range(1 << h)} + assert len(back) == 1 << h + return [gf_linear(b, back[1 << j]) for j in range(h)] diff --git a/research/t74-joint-twelve-retired7/vendor/target_transport.py b/research/t74-joint-twelve-retired7/vendor/target_transport.py new file mode 100644 index 0000000000..89ee0168c6 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/target_transport.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Exact target-vector transport; no physical/native admission is implied. + +For a final correction c, compute the unique simultaneous correction at every +boundary of a target-affine gate word. Non-target source terms cancel from the +difference. Transport through target mixing, not only target scales. +""" +from fractions import Fraction as Q + + +def need(ok, msg): + if not ok: + raise RuntimeError(msg) + + +def step(c, gate, targets, inverse=False): + out=dict(c) + kind=gate[0] + if kind not in ('add','scale'): + return out + t=gate[1] + if kind=='add': + s=gate[2] + need(not (s in targets and t not in targets), 'non-target reads target') + if t in targets and s in targets: + a=Q(gate[3],gate[4])*(-1 if inverse else 1) + out[t]=out.get(t,Q(0))+a*out.get(s,Q(0)) + elif t in targets: + a=Q(gate[2],gate[3]);need(a!=0,'zero target scale') + out[t]=out.get(t,Q(0))*(1/a if inverse else a) + return {t:a for t,a in out.items() if a} + + +def suffix_corrections(gates, final, targets): + need(set(final)<=set(targets),'correction outside targets') + c={t:Q(a) for t,a in final.items() if a} + vectors=[c] + for g in reversed(gates): + c=step(c,g,targets,inverse=True) + vectors.append(c) + return list(reversed(vectors)) + + +def verify_transport(gates, final, targets): + vectors=suffix_corrections(gates,final,targets) + need(len(vectors)==len(gates)+1,'missing boundary') + for i,g in enumerate(gates): + need(step(vectors[i],g,targets)==vectors[i+1],f'transport boundary {i}') + need(vectors[-1]=={t:Q(a) for t,a in final.items() if a},'wrong final') + return vectors + + +def controls(): + # A correction on source target 11 is mixed into target 10 by an ADD; + # a scalar-only backward transport would miss this exact obstruction. + targets={10,11};gates=[['add',10,11,3,2,[]],['scale',11,-2,1,[]]] + final={10:Q(5),11:Q(4)} + v=verify_transport(gates,final,targets) + need(v[0]=={10:Q(8),11:Q(-2)},'known noncommuting two-target example') + wrong=dict(v[0]);wrong[10]=Q(5) + for g in gates:wrong=step(wrong,g,targets) + need(wrong!=final,'ignored-mixing control accepted') + try:step({10:Q(1)},['add',0,10,1,1,[]],targets) + except RuntimeError:pass + else:raise RuntimeError('target read into non-target not rejected') + return {'noncommuting_target_mix':'rejected_scalar_only_transport','non_target_read':'rejected'} + + +if __name__=='__main__': + need(__debug__,'assertions must remain enabled') + controls() + print('PASS_EXACT_TARGET_TRANSPORT_CONTROLS') diff --git a/research/t74-joint-twelve-retired7/vendor/word_patch_pr2679.py b/research/t74-joint-twelve-retired7/vendor/word_patch_pr2679.py new file mode 100644 index 0000000000..492a3ef831 --- /dev/null +++ b/research/t74-joint-twelve-retired7/vendor/word_patch_pr2679.py @@ -0,0 +1,65 @@ +"""word_patch.py: exact structural edits of a BORROW-WORD (kernel edits found on the borrowed words, applied on top of the pinned rebuild). +apply_kernel(word, patch) replaces the sections listed in patch['sections'] (B, warps, and frame-only A/restore changes) and re-derives the explicit inverse-reverse cleanup exactly as build_word.py does; +kernel_gate_edit(old_B, new_B) returns the gate-level edit (frames ignored) that turns the old B section into the new one, so the edit declared in the patch can be checked.""" +import copy,difflib,json +V=112;N=704;FULL=[256,128,64,32,16,8,4,2,1] +def _key(g):return json.dumps(g[:-1]) +def kernel_gate_edit(old_B,new_B): + """[('delete',i,gate) | ('insert',i_new,gate)] between the two B sections, ignoring the trailing frame of every gate""" + ka=[_key(g) for g in old_B];kb=[_key(g) for g in new_B];ed=[] + for t,i1,i2,j1,j2 in difflib.SequenceMatcher(None,ka,kb,autojunk=False).get_opcodes(): + if t in('delete','replace'):ed+=[['delete',i,old_B[i][:-1]] for i in range(i1,i2)] + if t in('insert','replace'):ed+=[['insert',j,new_B[j][:-1]] for j in range(j1,j2)] + return ed +def derive_cleanup(w,restored): + byp={} + for op,rec in enumerate(w['warps'],1):byp.setdefault(rec[0],[]).append((op,rec)) + fw=list(w['A']) + for p in range(len(w['B'])+1): + for op,rec in sorted(byp.get(p,[]),key=lambda x:x[0]):fw.append(['warp',rec[1],op]) + if p=N}|{g[2]-N for g in w['cleanup'] if g[0]=='add' and g[2]>=N} +def apply_kernel(w,patch): + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['sections'].items():r[k]=copy.deepcopy(v) + r['report']['local_profile']=patch['local_profile'] + r['cleanup']=derive_cleanup(r,rs) + return r + +def apply_handoff(w,patch): + """coherent multi-helper handoff edit (retired-source replacement of high roles): replace the listed top-level fields and the report, re-derive the cleanup from the changed word""" + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + r['cleanup']=derive_cleanup(r,rs) + return r + +def apply_lowfour(w,patch): + """four low aliases through lifted-target compensation (PR2436 mechanism): replace the listed fields; the A section starts with the + explicit prelude (patch fields['prelude_events'] leading items); the inverse-reverse cleanup is derived WITHOUT the prelude.""" + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + t=copy.deepcopy(r);t['A']=r['A'][r['prelude_events']:] + r['cleanup']=derive_cleanup(t,rs) + return r + +def apply_prelife(w,patch): + """pre-life hosting (this package): a cold host h, after it has restored itself and retired, hosts the whole life of a dim-0-start + helper L through one B warp; h stops being cold, so the restored (private-buffer) set of the derived cleanup is the NEW helper_final + key set (not the input word's). Replace the listed fields and the report; re-derive the inverse-reverse cleanup without the prelude.""" + r=copy.deepcopy(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + t=copy.deepcopy(r);t['A']=r['A'][r.get('prelude_events',0):] + r['cleanup']=derive_cleanup(t,{int(q) for q in r['helper_final']}) + return r diff --git a/research/t74-joint-twelve-retired7/verify.py b/research/t74-joint-twelve-retired7/verify.py new file mode 100644 index 0000000000..d8101f1a28 --- /dev/null +++ b/research/t74-joint-twelve-retired7/verify.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Read-only finite replay: words, corrections, cleanup, hosting and exact moment. +No assertion-optimized execution; full native/outer release is separate. +""" +import copy,gzip,hashlib,json +from pathlib import Path +from fractions import Fraction as F +import sys +sys.path.insert(0,str(Path(__file__).resolve().parent)) +import composition as C +import independent_local as L +import independent_owners as I +import exact_moment as M +HERE=Path(__file__).resolve().parent +PROFILE={1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} +LOW=F('0.001717794984118634663827') +PROFILE2751={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +LOW2751=F('0.001717141586348426338109') +ALIASES=[(606,550),(635,551),(637,552),(638,553),(639,562)] # retired5 +NEW7=[(667,401),(669,403)] # retired7: retired-lender aliases enabled by moving the hostees of warps 30/31 onto 564/565 +import importlib.util as _iu +_s=_iu.spec_from_file_location('word_patch_pr2679',Path(__file__).resolve().parent/'vendor/word_patch_pr2679.py');WP=_iu.module_from_spec(_s);_s.loader.exec_module(WP) +def refit_apply(w0,p): + w=copy.deepcopy(w0) + for sec,i,fr in p['frames']: + need(w[sec][i][:-1]==w0[sec][i][:-1],'refit changes a gate');w[sec][i][-1]=fr + w['report']['local_profile']=p['local_profile'];return w +def compact(fill,old_words,new_words,old_prov,new_prov,order,dispatch): + live=lambda w:[r for r in range(224,704) if r not in set(w['removed'])] + L0=live(old_words['gauge44']);L1=live(new_words['gauge44']);need(L0==live(old_words['extra']) and L1==live(new_words['extra']),'live helper sets') + gone=set(L0)-set(L1);need(set(L1)<=set(L0) and sorted(gone)==sorted([h for h,_ in ALIASES]+[h for h,_ in NEW7]),'removed helpers') + i1={r:i for i,r in enumerate(L1)};bins={} + for pid in ('gauge44','extra'):need([old_prov[pid]['widths'][L0.index(r)] for r in L1]==new_prov[pid]['widths'],'renumbered widths') + for t,h,o,c,p,off in fill['rows']: + if L0[h] in gone:continue + bins.setdefault((o,c,p),[]).append([t,i1[L0[h]],o,c,p,off]) + rows=[] + for key,rs in bins.items(): + rs.sort(key=lambda x:x[5]);pos=0 + for x in rs:x[5]=pos;pos+=new_prov[dispatch[tuple(order[x[0]])]]['widths'][x[1]];rows.append(x) + rows.sort(key=lambda x:(x[0],x[1]));return dict(fill,rows=rows) +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(name): + p=HERE/'inputs'/name;b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def run(): + need(__debug__,'run without -O: inherited independent local checker uses assertions') + pins=json.loads((HERE/'INPUT-PINS.json').read_text()) + for path,digest in pins.items():need(hashlib.sha256((HERE/path).read_bytes()).hexdigest()==digest,'input digest '+path) + claim=json.loads((HERE/'CLAIM.json').read_text()) + need({int(k):v for k,v in claim['profile'].items()}==PROFILE,'claim profile') + need(F(claim['complex_lower'])==LOW and F(claim['complex_upper'])==LOW+F(1,10**24),'claim bracket') + need(F(claim['kappa'])==LOW-F(1,10**46)-F(1,10**70),'claim outer endpoint') + for name in ('PR2733','PR2745','PR2751','PR2766','PR2767'): + previous=json.loads((HERE/'evidence'/(f'{name}-OUTER-CLAIM.json' if name=='PR2767' else f'{name}-CLAIM.json')).read_text()) + need(F(claim['kappa'])>F(previous['kappa']),'strict improvement over '+name) + words={} + for tag,pid in [('base','gauge44'),('extra','extra')]: + w=rd('WORD-'+tag+'.json.gz');words[pid]=w + L.check_frames(w);L.check_cleanup(w);L.algebra(w) + need(set(int(t)+112 for t in w['target_levels']).isdisjoint(g[1] for g in w['cut']),'lifted targets avoid every cut read') + for label in ['drop_anticipatory','reverse_anticipatory','reverse_recovery']: + bad=copy.deepcopy(w) + if label=='drop_anticipatory':bad['initial_corrections'].pop() + elif label=='reverse_anticipatory':bad['initial_corrections'][0]['coefficient']=str(-F(bad['initial_corrections'][0]['coefficient'])) + else: + j=next(i for i,g in enumerate(bad['B']) if g[:5]==['add',49,33,-1,1]);bad['B'][j][3]=1 + try:L.algebra(bad) + except AssertionError:pass + else:raise ValueError('accepted mutation '+label) + order,fill,providers=rd('ORDER.json'),rd('FILL.json.gz'),rd('PROVIDERS.json') + dispatch={(s,r):p for s,r,p in rd('DISPATCH.json.gz')} + need(order==rd('SOURCE-ORDER.json'),'source order') + # retired5: PR2751's own construction (its words, providers and fill) is reproduced first ... + words51={'gauge44':rd('WORD2751-base.json.gz'),'extra':rd('WORD2751-extra.json.gz')};prov51=rd('PROVIDERS2751.json');fill51=rd('FILL2751.json.gz') + constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),prov51,rd('SOURCE-FILL.json.gz'),order,dispatch,words51) + need(constructed==fill51,'complete deterministic PR2751 fill') + # ... then the declared stages turn its words into the candidate words exactly ... + for tag,pid in [('base','gauge44'),('extra','extra')]: + w=refit_apply(words51[pid],rd('refit5_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias5_43'+tag+'.json'));w=refit_apply(w,rd('refit5c_43'+tag+'.json')) + w=refit_apply(w,rd('refit7_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('hostmove2_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias7_43'+tag+'.json'));w=refit_apply(w,rd('refit7c_43'+tag+'.json')) # retired7 + need(w==words[pid],'declared stages reproduce the candidate word '+tag) + d2=dict(dispatch) + for s,r,p in fill['dispatch_overrides']:d2[s,r]=p + # ... and the candidate fill is PR2751's fill with the seven removed helpers' roles dropped, renumbered and re-tiled as bin prefixes + need(compact(fill51,words51,words,prov51,providers,order,d2)==fill,'complete deterministic candidate fill') + owner=I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,fill,providers,dispatch,PROFILE) + bad=copy.deepcopy(fill);bad['rows'][0][5]=999 + try:I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,bad,providers,dispatch,PROFILE) + except (ValueError,RuntimeError):pass + else:raise ValueError('accepted out-of-bin placement') + _,a=M.moment_bounds(PROFILE,LOW);b,_=M.moment_bounds(PROFILE,LOW+F(1,10**24));need(a<6630466304,'PR2751 rejects candidate endpoint') + return {'status':'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} +if __name__=='__main__':print(json.dumps(run(),indent=2)) diff --git a/research/t74-joint-twelve-retired7/verify_retired7.py b/research/t74-joint-twelve-retired7/verify_retired7.py new file mode 100644 index 0000000000..0f2c1ee50f --- /dev/null +++ b/research/t74-joint-twelve-retired7/verify_retired7.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +# retired7 extension of verify_retired5.py (same author). +"""Bounded replay of retired7 on PR2751's words: the five retired-lender aliases (retired5 stages) plus two hostee moves that free +two more retired lenders (retired7 stages refit7 -> hostmove2 -> alias7 -> refit7c). Read-only, standard library only. + +1. Rebuilds both candidate words from PR2751's words through the seven declared stages (refit5, alias5, refit5c, refit7, hostmove2, + alias7, refit7c) and checks each stage's declared structure exactly. +2. Runs the pinned PR2679 BORROW-WORD auditor (vendor/audit_local_pr2679.py, byte-identical) on every state. +3. Tamper controls, each rejected by that auditor for a real reason: every lender refit undone (warp frame mismatch), every + follower raise undone, the PR2679 alias suite (7 mutations per alias, cleanup re-derived), one certified frame corrupted. +4. Literal owner check of the complete fill (independent_owners.py, integer chronology and bit-mask bins). +5. Exact endpoint: rational adjacent bracket of the moment root at 1e-24, an 80-digit decimal root, and + kappa = C - 10^-46 - 10^-70 strictly above the pinned exact claims of PR2751, PR2766 and PR2767. +""" +import contextlib, copy, gzip, hashlib, importlib.util, io, json, sys, tempfile +from decimal import Decimal, getcontext +from fractions import Fraction as F +from pathlib import Path +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +sys.path.insert(0, str(HERE)) +ALIASES = [(606, 550), (635, 551), (637, 552), (638, 553), (639, 562)] +MOVES = [(30, 401, 564, 911), (31, 403, 565, 912)] # retired7: (warp op, old lender, new lender, new lender's last B gate) +NEW7 = [(667, 401), (669, 403)] +H5 = [h for h, _ in ALIASES]; L5 = [L for _, L in ALIASES] +def need(ok, msg): + if not ok: raise ValueError(msg) +def rd(name): + p = HERE / name; b = p.read_bytes(); return json.loads(gzip.decompress(b) if p.suffix == '.gz' else b) +def load(name, path): + s = importlib.util.spec_from_file_location(name, path); m = importlib.util.module_from_spec(s); s.loader.exec_module(m); return m +def regs(e): return e[1:3] if e[0] == 'add' else e[1:2] +def refit_apply(w0, p): + w = copy.deepcopy(w0) + for sec, i, fr in p['frames']: + need(w[sec][i][:-1] == w0[sec][i][:-1], 'refit changes a gate'); w[sec][i][-1] = fr + w['report']['local_profile'] = p['local_profile']; return w +def frames_only(x, y): + need(set(x) == set(y) and all(x[k] == y[k] for k in x if k not in ('A', 'B', 'restore', 'report')), 'non-frame field changed') + need(all(len(x[k]) == len(y[k]) and all(a[:-1] == b[:-1] for a, b in zip(x[k], y[k])) for k in ('A', 'B', 'restore')), 'gate changed') + return {(k, i) for k in ('A', 'B', 'restore') for i, (a, b) in enumerate(zip(x[k], y[k])) if a != b} +def main(): + need(__debug__, 'run without -O: the pinned auditor and these checks use assertions') + pins = rd('INPUT-PINS.json') + for path, digest in pins.items(): need(hashlib.sha256((HERE / path).read_bytes()).hexdigest() == digest, 'input digest ' + path) + for name, digest in (('vendor/audit_local_pr2679.py', AUDITOR_SHA), ('vendor/word_patch_pr2679.py', WORD_PATCH_SHA)): + need(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == digest, 'vendored source pin ' + name) + AU = load('audit_local_pr2679', HERE / 'vendor/audit_local_pr2679.py'); WP = load('word_patch_pr2679', HERE / 'vendor/word_patch_pr2679.py') + import independent_owners as I, exact_moment as M, retired7_controls as R7 + tmp = Path(tempfile.mkdtemp(prefix='retired5-')) + def audit(w, name): + p = tmp / (name + '.json.gz'); p.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode(), mtime=0)) + try: + with contextlib.redirect_stdout(io.StringIO()): AU.run(p, tmp / (name + '.out.json'), None, None) + return None + except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as exc: + return (type(exc).__name__ + ': ' + str(exc))[:200] + def rederive(m, ref): + m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(ref)); m2['A'] = A; return m2 + out = dict(words={}, controls={}) + for tag in ('base', 'extra'): + w0 = rd(f'inputs/WORD2751-{tag}.json.gz'); final = rd(f'inputs/WORD-{tag}.json.gz') + p1, p2, p3 = rd(f'inputs/refit5_43{tag}.json'), rd(f'inputs/alias5_43{tag}.json'), rd(f'inputs/refit5c_43{tag}.json') + s1 = refit_apply(w0, p1); ch1 = frames_only(w0, s1); need(ch1 == {(s, i) for s, i, _ in p1['frames']}, 'refit5 declared frames') + lastL = {L: max(p for p, e in enumerate(w0['B']) if L in regs(e)) for L in L5}; firstH = {h: min(p for p, e in enumerate(w0['B']) if h in regs(e)) for h in H5} + need(all(lastL[L] < firstH[h] for h, L in ALIASES) and not any(L in regs(e) for L in L5 for e in w0['restore']), 'lenders retired before their followers enter') + need(all(len(s1['B'][p][-1]) == len(w0['B'][p][-1]) - 1 == 5 for p in lastL.values()), 'lender last gates lowered 6 -> 5') + need(all(len(s1['B'][p][-1]) == len(w0['B'][p][-1]) + 1 == 5 for p in firstH.values()), 'follower first gates raised 4 -> 5') + s2 = WP.apply_lowfour(s1, p2) + need(WP.kernel_gate_edit(s1['B'], s2['B']) == p2['declared_gate_edit'] and sorted(set(s2['removed']) - set(s1['removed'])) == H5, 'alias5 declared edit and removed helpers') + need(s2['warps'][:len(s1['warps'])] == s1['warps'] and [x[1] for x in s2['warps'][len(s1['warps']):]] == L5 and all(len(x[3]) == len(x[4]) == 5 for x in s2['warps'][-5:]), 'alias5 warps') + need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p2['aliases']] == s2['warps'][-5:] and s2['A'] == s1['A'] and s2['restore'] == s1['restore'], 'alias5 records') + need(s2['start_extra'] == {k: v for k, v in s1['start_extra'].items() if int(k) not in H5} and not any(h in regs(e) for h in H5 for e in s2['B'] + s2['restore']), 'helpers fully removed') + need(all(s2[k] == s1[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias5 changes nothing else') + s3 = refit_apply(s2, p3); ch3 = frames_only(s2, s3); need(ch3 == {(s, i) for s, i, _ in p3['frames']}, 'refit5c declared frames') + p4, p5, p6, p7 = (rd(f'inputs/{n}_43{tag}.json') for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')) + s4 = refit_apply(s3, p4); ch4 = frames_only(s3, s4); need(ch4 == {('B', g) for _, _, _, g in MOVES} == {(s, i) for s, i, _ in p4['frames']}, 'refit7 declared frames') + need(all(len(s3['B'][g][-1]) == 6 and len(s4['B'][g][-1]) == 5 and L1 in regs(s3['B'][g]) and max(p for p, e in enumerate(s3['B']) if L1 in regs(e)) == g for _, _, L1, g in MOVES), 'new lenders: last gates lowered 6 -> 5') + need(not any(L1 in regs(e) for _, _, L1, _ in MOVES for e in s3['restore']) and p4['previous_frames'] == [[s, i, s3[s][i][-1]] for s, i, _ in p4['frames']], 'new lenders retired; previous frames recorded') + s5 = WP.apply_lowfour(s4, p5) + need(WP.kernel_gate_edit(s4['B'], s5['B']) == p5['declared_gate_edit'] and s5['removed'] == s4['removed'] and s5['start_extra'] == s4['start_extra'], 'hostmove2 declared edit') + for i, (a, b) in enumerate(zip(s4['B'], s5['B'])): + c = list(a) + for op, L0, L1, _ in MOVES: + if i >= s4['warps'][op - 1][0]: c = [L1 if (j in (1, 2) if c[0] == 'add' else j == 1) and x == L0 else x for j, x in enumerate(c)] + need(c[:-1] == b[:-1], 'hostmove2 is exactly the relabel of the hostees from their warp positions') + need([i for i, (x, y) in enumerate(zip(s4['warps'], s5['warps'])) if x != y] == [op - 1 for op, _, _, _ in MOVES] and len(s5['warps']) == len(s4['warps']), 'hostmove2 replaces exactly warps 30 and 31 in place') + need(all(s4['warps'][op - 1][1] == L0 and s5['warps'][op - 1][1] == L1 and len(s5['warps'][op - 1][3]) == len(s5['warps'][op - 1][4]) == 5 and s5['warps'][op - 1][0] > g for op, L0, L1, g in MOVES), 'moved warps: new lenders, dim 5, after the lenders retire') + need([[m['pos'], m['L_new'], m['G'], m['U'], m['E']] for m in p5['moves']] == [s5['warps'][op - 1] for op, _, _, _ in MOVES] and [m['old_record'] for m in p5['moves']] == [s4['warps'][op - 1] for op, _, _, _ in MOVES], 'hostmove2 records') + need(all(not any(L0 in regs(e) for e in s5['B'] + s5['restore']) for _, L0, _, _ in MOVES), 'old lenders untouched after their A lives') + need(all(s5[k] == s4[k] for k in ('A', 'restore', 'helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'hostmove2 changes nothing else') + s6 = WP.apply_lowfour(s5, p6); H7 = [h for h, _ in NEW7]; L7 = [L for _, L in NEW7] + need(WP.kernel_gate_edit(s5['B'], s6['B']) == p6['declared_gate_edit'] and s6['removed'] == s5['removed'] + H7, 'alias7 declared edit and removed helpers') + need(s6['warps'][:len(s5['warps'])] == s5['warps'] and [x[1] for x in s6['warps'][len(s5['warps']):]] == L7 and all(len(x[3]) == len(x[4]) == 4 for x in s6['warps'][-2:]), 'alias7 warps') + need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p6['aliases']] == s6['warps'][-2:] and [a['h'] for a in p6['aliases']] == H7 and s6['A'] == s5['A'] and s6['restore'] == s5['restore'], 'alias7 records') + need(all(max([p for p, e in enumerate(s5['B']) if L in regs(e)], default=-1) < min(p for p, e in enumerate(s5['B']) if h in regs(e)) for h, L in NEW7) and not any(L in regs(e) for L in L7 for e in s5['restore']), 'alias7 lenders retired before their followers enter') + need(s6['start_extra'] == {k: v for k, v in s5['start_extra'].items() if int(k) not in H7} and not any(h in regs(e) for h in H7 for e in s6['B'] + s6['restore']), 'alias7 helpers fully removed') + need(all(s6[k] == s5[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias7 changes nothing else') + s7 = refit_apply(s6, p7); ch7 = frames_only(s6, s7); need(ch7 == {(s, i) for s, i, _ in p7['frames']}, 'refit7c declared frames') + need(s7 == final, 'declared stages rebuild the candidate word ' + tag) + for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('retired5', s3), ('refit7', s4), ('hostmove2', s5), ('alias7', s6), ('candidate', s7))): + r = audit(w, f'{tag}-{name}'); need(r is None, f'auditor rejects {tag} {name}: {r}') + c = {} + for L, p in lastL.items(): + m = copy.deepcopy(final); m['B'][p][-1] = w0['B'][p][-1]; r = audit(m, f'{tag}-lender{L}'); c[f'lender {L} refit undone'] = r; need(r is not None and 'warp frame mismatch' in r, f'{tag} lender {L} refit undone not rejected by warp frame mismatch: {r}') + for h, p in firstH.items(): + m = copy.deepcopy(final); m['B'][p][-1] = w0['B'][p][-1]; r = audit(m, f'{tag}-follower{h}'); c[f'follower {h} raise undone'] = r; need(r is not None, f'{tag} follower {h} raise undone accepted') + for a in p2['aliases']: + h, L = a['h'], a['L']; op = next(i for i, x in enumerate(final['warps']) if x[1] == L and x[0] == a['pos']) + reads = [i for i, g in enumerate(final['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] + writes = [i for i, g in enumerate(final['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] + muts = [] + m = copy.deepcopy(final); m['B'][reads[0]][3] *= -1; muts.append(('borrowed read sign flipped', m)) + m = copy.deepcopy(final); m['B'][reads[0]][3] *= 2; muts.append(('borrowed read doubled', m)) + if writes: m = copy.deepcopy(final); m['B'][writes[0]][3] *= -1; muts.append(('borrowed write sign flipped', m)) + m = copy.deepcopy(final); del m['warps'][op] + for e in m['A'][:m['prelude_events']]: + if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 + muts.append(('warp dropped', m)) + m = copy.deepcopy(final); m['warps'][op][2][0] ^= m['warps'][op][2][1]; muts.append(('G wrong', m)) + m = copy.deepcopy(final); m['warps'][op][0] = a['pos'] - 400; muts.append(('warp before lender retirement', m)) + m = copy.deepcopy(final); m['start_extra'][str(h)] = a['E']; muts.append(('helper kept with an entrance frame', m)) + for nm, m in muts: + r = audit(rederive(m, final), f'{tag}-{h}-{nm.replace(" ", "_")}'); c[f'{h}<-{L} {nm}'] = r + need(r is not None and not r.split(': ', 1)[-1].startswith(('explicit cleanup differs', 'warp operator id')), f'{tag} {h}<-{L} {nm}: not rejected for a real reason: {r}') + sec, i, fr = p3['frames'][len(p3['frames']) // 2]; m = copy.deepcopy(final); m[sec][i][-1] = [1]; r = audit(m, f'{tag}-refit5c-tamper'); c['certified frame corrupted'] = r; need(r is not None, f'{tag} refit5c tamper accepted') + ok7, c7 = R7.controls(final, p4, p5, p6, p7, lambda w: audit(w, f'{tag}-r7'), WP); need(ok7, f'{tag} retired7 controls: ' + json.dumps({k: v['reason'] for k, v in c7.items() if not v['real_reason']})[:300]) + c.update({k: v['reason'] for k, v in c7.items()}) + out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), refit7_frames=len(ch4), hostmove2_gate_edits=len(p5['declared_gate_edit']), alias7_gate_edits=len(p6['declared_gate_edit']), refit7c_frames=len(ch7), retired7_controls=len(c7), local_profile=final['report']['local_profile']) + out['controls'][tag] = {k: v[:90] for k, v in c.items()} + # literal owner check of the complete candidate fill + order, fill, providers = rd('inputs/ORDER.json'), rd('inputs/FILL.json.gz'), rd('inputs/PROVIDERS.json') + dispatch = {(s, r): p for s, r, p in rd('inputs/DISPATCH.json.gz')} + profile = {int(k): v for k, v in rd('CLAIM.json')['profile'].items()} + owner = I.check(rd('inputs/PLAN.json.gz'), rd('inputs/GLOBAL-TEMPLATE.json.gz'), order, fill, providers, dispatch, profile) + need(owner['roles'] == 666 * 408 and owner['helpers_per_call'] == 408, 'owner fill size') + # exact endpoint and kappa + claim = rd('CLAIM.json'); C = F(claim['complex_lower']) + need(F(claim['complex_upper']) == C + F(1, 10 ** 24) and C.denominator <= 10 ** 24 and (C * 10 ** 24).denominator == 1, 'endpoint is a 1e-24 grid point') + _, a = M.moment_bounds(profile, C); b, _ = M.moment_bounds(profile, C + F(1, 10 ** 24)); need(a < 66304 < b, 'exact adjacent root bracket') + getcontext().prec = 90 + def g(z): return sum(Decimal(n) * (Decimal(r) / 73) ** (1 - z) for r, n in profile.items()) - 66304 + def dg(z): return sum(-Decimal(n) * (Decimal(r) / 73) ** (1 - z) * (Decimal(r) / 73).ln() for r, n in profile.items()) + z = Decimal(C.numerator) / Decimal(C.denominator) + for _ in range(8): z -= g(z) / dg(z) + need(F(str(z)) >= C and F(str(z)) < C + F(1, 10 ** 24), '80-digit root inside the certified bracket') + K = F(claim['kappa']); need(K == C - F(1, 10 ** 46) - F(1, 10 ** 70), 'claim kappa = C - 1e-46 - 1e-70') + margins = {} + for name, rel in (('PR2751', 'evidence/PR2751-CLAIM.json'), ('PR2766', 'evidence/PR2766-CLAIM.json'), ('PR2767', 'evidence/PR2767-OUTER-CLAIM.json')): + k = F(rd(rel)['kappa']); need(K > k, 'strict improvement over ' + name); d = K - k + margins[name] = dict(decimal=str(Decimal(d.numerator) / Decimal(d.denominator))[:40], exact=str(d) if len(str(d)) < 120 else 'K - kappa(' + rel + ')') + out.update(status='PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), + complex_lower=str(C), root_80_digits=str(+z)[:82], kappa=str(K), margins=margins, + scope='Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py).') + print(json.dumps(out, indent=1)) +AUDITOR_SHA = 'a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90' +WORD_PATCH_SHA = '9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce' +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve-retired7/workflow/admit.py b/research/t74-joint-twelve-retired7/workflow/admit.py new file mode 100644 index 0000000000..282ff24766 --- /dev/null +++ b/research/t74-joint-twelve-retired7/workflow/admit.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a composed-word COMPOSED order/fill derivative. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-pr2733' +SOURCE_MANIFEST = '9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' # retired7 derived source: PR2751 overlay + five retired-lender aliases + two hostee moves and two aliases +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'native-cache', 'native-receipt', 'work'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + a = ap.parse_args() + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == 506 and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + write(work / 'RUNTIME-PATCHES.json', patches) + shutil.copy2(a.fill, package / 'new/borrow-fill/FILL.json.gz') + shutil.copy2(a.order, package / 'new/borrow-fill/ORDER.json') + run('owners', package / 'reconstruct.py', '--out', work / 'owners') + run('parent-lift', package / 'lift_parent.py', '--owners', work / 'owners', '--out', work / 'parent-data') + for name in ('PLAN.json', 'OWNERS.json.gz', 'DISPATCH.json', 'PROFILE.json', 'CONSTRUCTION.json', + 'GLOBAL-TEMPLATE.json.gz', 'SPEC.json'): + shutil.copy2(work / 'parent-data' / name, package / name) + shutil.copy2(work / 'owners/ORDER.json', package / 'ORDER.json') + spec = read(package / 'SPEC.json') + spec['outer_refinement'] = PRECISION + spec['expected']['live'] = 66304 + # COMPOSED's pre-life mechanism changes which helper labels retain width8. + # Preserve its declared spot set; rebind and the original strict verifier + # still check the actual native widths, including every other helper. + source_spots = read(source / 'new/SPEC.json')['width_spot_helpers'] + need(source_spots == [278, 281, 284, 289], 'COMPOSED source spot-width pins') + spec['width_spot_helpers'] = source_spots + write(package / 'new/SPEC.json', spec) + run('rebind', package / 'new/rebind.py', package, natives['base'] / 'local', + natives['extra'] / 'local', work / 'rebound') + spec = read(work / 'rebound/SPEC.json') + need(spec['expected']['physical'] == 66794, 'complete physical cost including 72 buffers (R 408)') + layout = work / 'layout' + layout.mkdir() + with tarfile.open(old / 'upstream-layout.tar.gz') as archive: + need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + for m in archive.getmembers()), 'retained archive paths') + archive.extractall(layout, filter='data') + runtime = layout / 'packing74' + runtime.mkdir() + for name in ('replay.py', 'freeze_spec.py', 'audit_mixed.py', 'independent_core.py', 'geometry_controls.py', 'audit_fast.py'): + shutil.copy2(package / name, runtime / name) + for name in ('code', 'construction', 'inputs'): + shutil.copytree(package / name, runtime / name) + shutil.copytree(work / 'rebound', runtime / 'candidate') + shutil.copytree(natives['extra'], runtime / 'native-extra') + data = runtime / 'candidate' + result = dict(status='PREPARED_COMPOSED_SAME_WORD_DERIVATIVE_NOT_ADMITTED', source_commit=SOURCE_COMMIT, + source_manifest_sha256=SOURCE_MANIFEST, native_receipt_sha256=sha(a.native_receipt), + fill_sha256=sha(package / 'new/borrow-fill/FILL.json.gz'), + order_sha256=sha(package / 'new/borrow-fill/ORDER.json'), profile=read(work / 'rebound/PROFILE.json'), + patches=patches, scope='Prepared only; source/native/parent inputs authenticated and literal owner fill reconstructed.') + write(work / 'RESULT.json', result) + if a.prepare_only: + print(result['status'], flush=True) + return + run('discovery', runtime / 'replay.py', '--data', data, '--work', work / 'discovery', + '--local', natives['base'] / 'local', '--discover') + supplier = read(work / 'discovery/RESULT.json') + for name in ('PLAN.json', 'PROFILE.json', 'SPEC.json'): + shutil.copy2(data / name, package / 'new' / name) + spec = read(package / 'new/SPEC.json') + original_claim = read(source / 'CLAIM.json') + claim = dict(status='CONDITIONAL_CANDIDATE_EXPECTED_BY_REPLAY', kappa=supplier['kappa'], + kappa_decimal=supplier['kappa_decimal'], baseline_pr=2679, baseline_head=SOURCE_COMMIT, + baseline_kappa=read(source / 'outer/OUTER-CLAIM.json')['kappa'], outer_refinement=PRECISION, + scope=original_claim['scope'], kappa_layers=original_claim['kappa_layers'], + headline_kappa_source='outer/OUTER-CLAIM.json', + verification='Candidate discovered from literal fill; full original verification must pass separately.') + write(package / 'CLAIM.json', claim) + C = Q(spec['expected']['complex_lower']) + write(package / 'outer/B.json', dict(b=str(C-Q(1,10**104)), b_above_endpoint=str(C+Q(1,10**24)), + profile=spec['expected']['global_profile'], live=spec['expected']['live'])) + for name in ('check_ledger.py', 'independent_check.py'): + run('outer-' + name, package / 'outer' / name) + ledger = read(package / 'outer/LEDGER.json') + row = ledger['rows']['struct_boundary_radix_union']['kappa'] + kappa = Q(row['rational']) + previous = Q('0.0017161404259974415161889999999999999999999998999999999999999999999999') + need(kappa == C-Q(1,10**70)-Q(1,10**46) and kappa > previous and kappa > Q('17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000'), # retired5: also strictly above PR2751 + 'candidate must strictly improve pinned COMPOSED before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=SOURCE_COMMIT, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + result.update(status='PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve/CLAIM-LOG.txt b/research/t74-joint-twelve/CLAIM-LOG.txt new file mode 100644 index 0000000000..37a3be9470 --- /dev/null +++ b/research/t74-joint-twelve/CLAIM-LOG.txt @@ -0,0 +1,9 @@ +LOCAL CLAIM: joint twelve-source reassignment beyond the PR2720 fixed-old-path contract. +Explicit donor assignment; retained seed2; last fetched base c22e42de697334df85337e005864773cdc2bc98b. New fetch and REST/GraphQL metadata refresh failed with network timeout/reset; latest verified comparison PR2733 head2761b52b17590b8cf94f2e410004a8252d5592dc. Recheck overlap before submission. +Candidates considered: (1) reassign old four lifted aliases together with eight new source-partner aliases; (2) optimize shared chart choices of the eight aliases under fixed paths, excluded as a centre improvement by PR2720; (3) new pre-life hosts after reassignment, no fixed-frame alias found and loose gap candidates appear inherited. Chosen(1). +Exact object: rebuild before lowfour with positive reconstruction of2462; recover source pairs33/49,55/101,74/83,85/98 after their last original uses; original four sources33,55,74,85 replace696,697,698,700, while2696eight remain680,681,682,684,688,689,690,692. Derive all target corrections from full arbitrary-input residual, transport through precondition/compensation, and lift targets to line45. Then six PR2679 pre-life substitutions and alias653<-563. +Bounded experiment: one deterministic assignment, both providers. No random search. Original and changed symbolic programs priced, forward/dual exact audits passed. Before implementing full admission, optimistic complete profile passes budget root approx0.001717141586348426338110, gain0.05834% over2733, all stock fixed at415helpers/72buffers. This is not yet a claimed conditional exponent. +Expected deliverable: complete source-bound construction, independent replay, negative controls, full native/supplier/outer checks and one focusedPR if it still improves latest. Finish target45minutes. Tekalign with substantial OpenAI Codex assistance; credits2436,2530,2679,2696,2733 and retained lineage. + +RESULT: Complete finite release passed. Public claim posting failed with integration403; this is a local claim. Public wrapper and latest-PR checks recorded separately. +Final public wrapper: PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE, explicit pristine local source/authenticated native cache. Registered Python3.12 final replay and integrity controls passed. Exact comparison is above PR2745 as well as PR2733. diff --git a/research/t74-joint-twelve/CLAIM.json b/research/t74-joint-twelve/CLAIM.json new file mode 100644 index 0000000000..48ad23a430 --- /dev/null +++ b/research/t74-joint-twelve/CLAIM.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717141586348426338109", + "complex_upper": "0.001717141586348426338110", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": 2733, + "comparison_head": "2761b52b17590b8cf94f2e410004a8252d5592dc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2745, + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "exact_claim": "evidence/PR2745-CLAIM.json" + } +} diff --git a/research/t74-joint-twelve/DERIVATIVE-CODE.patch b/research/t74-joint-twelve/DERIVATIVE-CODE.patch new file mode 100644 index 0000000000..15b163674a --- /dev/null +++ b/research/t74-joint-twelve/DERIVATIVE-CODE.patch @@ -0,0 +1,137 @@ +--- a/audit_mixed.py ++++ b/audit_mixed.py +@@ -9,7 +9,7 @@ + for _nm,_mut in (('changed lifted target frame',lambda b_:b_['target_levels'].__setitem__('23',0)),): + _bad=copy.deepcopy(w);_mut(_bad) + try:A.local_inventory(_bad,r,None) +- except ValueError as _e:A.require(str(_e)=='target line30','target mutation rejection') ++ except ValueError as _e:A.require(str(_e)=='candidate exact source-partner target frames','target mutation rejection') + else:raise ValueError('accepted changed lifted target') + _pg=A.read(d/'LOCAL-PROGRAMS.json.gz');_bp=copy.deepcopy(_pg);_bp['forward'].remove(next(e for e in _bp['forward'] if e[0]=='center')) + try:A.local_inventory(w,r,_bp) +--- a/independent_core.py ++++ b/independent_core.py +@@ -69,8 +69,7 @@ + External ports/frames are independently checked by audit_mixed.py. + """ + levels = {int(t): f for t, f in word['target_levels'].items()} +- require(set(levels) == {11,23,29,32,34,35,45,48,50,59,63,71,73,76,81,84,87,90,92,108}, 'twenty source-partner target offsets') +- require(all(frames[f] in ((30,), (45,)) for f in levels.values()), 'target line30') ++ require({str(t): list(frames[f]) for t, f in levels.items()} == {'104': [45], '106': [45], '110': [45], '14': [45], '21': [45], '37': [45], '41': [45], '43': [45], '47': [45], '52': [45], '78': [45], '99': [45]}, 'candidate exact source-partner target frames') + require(all(current[V+t] == frames[levels.get(t, 0)] for t in range(V)), 'target centre level') + forward, backward = [], [] + for index, (register, frame_id) in enumerate(zip(word['centers'], word['center_frames'])): +@@ -90,7 +89,7 @@ + origin = destination + forward.extend(segments) + backward.extend(e[:2]+[e[3], e[2], e[4]] for e in reversed(segments)) +- require(Counter(e[4] for e in forward) == {1:8, 7:8}, 'sixteen centre children') ++ require(Counter(e[4] for e in forward) == {8:8}, 'candidate eight unsplit centre children') + return {'forward': forward, 'backward': backward} + + +--- a/new/borrow/lowfour_controls.py ++++ b/new/borrow/lowfour_controls.py +@@ -20,12 +20,13 @@ + ia=next(i for i,e in enumerate(pre) if e[0]=='add') + m=mut();m['A'][ia][3]=-m['A'][ia][3];expect('prelude correction sign flipped',m) + m=mut();m['A'][ia][3]*=2;expect('prelude correction coefficient doubled',m) +- m=mut();m['A'][ia][1],m['A'][ia+1][1]=m['A'][ia+1][1],m['A'][ia][1];expect('prelude correction targets swapped',m) ++ jb=next(j for j,e in enumerate(pre) if e[0]=='add' and e[1]!=pre[ia][1] and e[2:]!=pre[ia][2:] and e[-1]==pre[ia][-1]) ++ m=mut();m['A'][ia][1],m['A'][jb][1]=m['A'][jb][1],m['A'][ia][1];expect('prelude correction targets swapped',m) + iw=[i for i,e in enumerate(pre) if e[0]=='warp'];m=mut();del m['A'][iw[1]];m['prelude_events']-=1;expect('prelude return warp dropped',m) + m=mut();del m['A'][iw[0]];m['prelude_events']-=1;expect('prelude forward warp dropped',m) +- ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==135];m=mut() ++ target=pre[ia][1];ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==target];assert ids;m=mut() + for i in reversed(ids):del m['A'][i] +- m['prelude_events']-=len(ids);expect('all prelude corrections of target 135 dropped',m) ++ m['prelude_events']-=len(ids);expect('all prelude corrections of actual first target dropped',m) + m=mut();m['A'][0][-1]=[31];expect('prelude target scale at a different line',m) + m=mut();m['A'][iw[0]][2]=m['A'][iw[0]][2]+1 if abs(m['A'][iw[0]][2])i:r[0]-=1 + expect('source restoration gate dropped (cleanup re-derived)',rederive(m)) + # rewritten helper gate on the borrowed source removed +- j=next(i for i,g in enumerate(w0['B']) if g[0]=='add' and g[1]==33 and g[2]==250) ++ j=next(i for i,g in enumerate(w0['B']) if i>=w0['warps'][W33][0] and g[0]=='add' and g[1]==33) + m=mut();del m['B'][j] + for r in m['warps']: + if r[0]>j:r[0]-=1 +--- a/new/code/borrow/bw_audit_local.py ++++ b/new/code/borrow/bw_audit_local.py +@@ -179,6 +179,17 @@ + def phase_at(es,name):return es.index(['phase',name]) + def first_warp(es,sign=1,start=0):return ev_index(es,lambda e:e[0]=='warp' and (e[2]>0)==(sign>0),start) + def cleanup_warp(es):return first_warp(es,-1,phase_at(es,'full_frame_cleanup')) ++def incomplete_centre_descent(es): ++ # Split paths lose an intermediate step. An unsplit path is truncated at ++ # an actual nested rank-one frame, with its child rank repriced correctly. ++ # Thus the control cannot fail merely because a split no longer exists. ++ indices=[i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0] ++ if indices: ++ es.pop(indices[0]);return ++ e=next(e for e in es if e[0]=='center') ++ stop=next(f for f in range(len(frames)) if len(frames[f])==1 and contains(frames[f],frames[e[2]])) ++ e[3]=stop;e[4]=len(frames[e[2]])-1 ++ + mutations=[ + ('wrong_scale',lambda es:next(e for e in es if e[0]=='scalar' and e[1][0]=='scale')[1].__setitem__(2,3)), + ('missing_center',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center'))), +@@ -194,7 +205,7 @@ + ('wrapper_on_a_centre_register',lambda es:next(e for e in es if e[0]=='residual_adapter').__setitem__(2,['C',0])), + ] if entering else [])+([ + ('centre_step_not_nested',lambda es:next(e for e in es if e[0]=='center').__setitem__(3,next(f for f in range(len(frames)) if not contains(frames[f],frames[next(e for e in es if e[0]=='center')[2]]) and not contains(frames[next(e for e in es if e[0]=='center')[2]],frames[f])))), +- ('centre_descent_step_skipped',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0))), ++ ('centre_descent_incomplete',incomplete_centre_descent), + ] if levels else [])+([ + ('hpe_pre_wrapper_resolved_to_full_recipe',lambda es:next(e for e in es if e[0]=='residual_adapter' and e[1]=='pre' and len(e)==5).pop()), + ('hpe_post_wrapper_without_terminal_frame',lambda es:next(e for e in es if e[0]=='residual_adapter' and len(e)==5).pop()), +--- a/new/rebuild_borrow.py ++++ b/new/rebuild_borrow.py +@@ -74,10 +74,10 @@ + lf=D/'inputs'/f'lowfour_43{wt}.json';lpatch=None + if lf.exists(): # four low aliases through lifted-target compensation (PR2436 mechanism) on top of the entrance state + lpatch=json.loads(lf.read_text());prev_l=chain[-1];chain.append(word_patch.apply_lowfour(prev_l,lpatch));steps.append('lowfour') +- nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[640,641,642,644]==lpatch['derived_removed_diff'] ++ nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[696,697,698,700]==lpatch['derived_removed_diff'] + kok&=[x[1:] for x in nw['warps'][:len(prev_l['warps'])]]==[x[1:] for x in prev_l['warps']] and [x[1] for x in nw['warps'][-4:]]==[33,55,74,85] and len(nw['warps'])==len(prev_l['warps'])+4 + kok&=[g[:-1] for g in nw['A'][nw['prelude_events']:]]==[g[:-1] for g in prev_l['A']] and nw['restore']==prev_l['restore'] and nw['helper_final']==prev_l['helper_final'] +- kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('640','641','642','644')}==nw['start_extra'] ++ kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('696','697','698','700')}==nw['start_extra'] + af=D/'inputs'/f'alias637_43{wt}.json';apatch=None + if af.exists(): # alias 637 borrowing retired source 31 (PR2436 pair) stacked on the four lifted-target aliases + apatch=json.loads(af.read_text());prev_a=chain[-1];chain.append(word_patch.apply_lowfour(prev_a,apatch));steps.append('alias637');na=chain[-1] +@@ -102,10 +102,10 @@ + kok&=word_patch.kernel_gate_edit(prev_p['B'],npl['B'])==ppatch['declared_gate_edit'] + kok&=all(npl[k_]==prev_p[k_] for k_ in ('A','precondition','cut','start_extra','target_levels','centers','center_frames','ports','prelude_events')) + rf2=D/'inputs'/f'refit563_43{wt}.json';rpatch2=None +- if rf2.exists(): # one-gate exact frame lowering (B 894, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) ++ if rf2.exists(): # one-gate exact frame lowering (B 904, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) + rpatch2=json.loads(rf2.read_text());prev_r=chain[-1];chain.append(refit_apply(prev_r,rpatch2));steps.append('refit563');nr=chain[-1] +- kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',894] and prev_r['B'][894][:5]==['add',515,563,1,1] +- kok&=len(nr['B'][894][-1])==len(prev_r['B'][894][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=894) ++ kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',904] and prev_r['B'][904][:5]==['add',515,563,1,1] ++ kok&=len(nr['B'][904][-1])==len(prev_r['B'][904][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=904) + kok&=not({515,563}&({x_['L'] for x_ in ppatch['pairs']}|{x_['h'] for x_ in ppatch['pairs']}) if ppatch else set()) + xf=D/'inputs'/f'alias1_43{wt}.json';xpatch=None + if xf.exists(): # retired-lender alias 653<-563 on the refit state (this package) +@@ -141,9 +141,9 @@ + pw_=Path(tempfile.mkdtemp())/'orig.json.gz';pw_.write_bytes(gzip.compress(json.dumps(prev_p,separators=(',',':')).encode(),mtime=0)) + pc=subprocess.run([sys.executable,'-B',str(D/'prelife_controls.py'),str(shipped),str(pw_),str(RCP/f'CONTROLS-PRELIFE-43{wt}.json')],capture_output=True,text=True) + pc_ok=pc.returncode==0 and json.loads((RCP/f'CONTROLS-PRELIFE-43{wt}.json').read_text())['all_rejected_for_expected_reason'];ok&=pc_ok;res['prelife_controls_ok']=pc_ok +- if rpatch2: # control: the shipped word with the B 894 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) ++ if rpatch2: # control: the shipped word with the B 904 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) + import copy as cp6 +- m=cp6.deepcopy(final);m['B'][894][-1]=prev_r['B'][894][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) ++ m=cp6.deepcopy(final);m['B'][904][-1]=prev_r['B'][904][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) + br=run_audit(bp,None,bp.parent/'refit563_undone.out.json');ru=br.returncode!=0 and 'warp frame mismatch' in (br.stdout+br.stderr);res['refit563_undone_rejected_by_warp_frame_mismatch']=ru;ok&=ru + if xpatch: + xc=subprocess.run([sys.executable,'-B',str(D/'alias1_controls.py'),str(shipped),str(xf),str(RCP/f'CONTROLS-ALIAS1-43{wt}.json')],capture_output=True,text=True) diff --git a/research/t74-joint-twelve/DERIVATIVE-OVERLAY.tar.gz b/research/t74-joint-twelve/DERIVATIVE-OVERLAY.tar.gz new file mode 100644 index 0000000000..46f7ce76d8 Binary files /dev/null and b/research/t74-joint-twelve/DERIVATIVE-OVERLAY.tar.gz differ diff --git a/research/t74-joint-twelve/EVIDENCE.json b/research/t74-joint-twelve/EVIDENCE.json new file mode 100644 index 0000000000..625b5d292e --- /dev/null +++ b/research/t74-joint-twelve/EVIDENCE.json @@ -0,0 +1,65 @@ +{ + "status": "PASS_FINITE_CONSTRUCTION_AND_COMPLETE_RELEASE", + "environment": { + "native_and_full_python": "3.14.7", + "bounded_python": "3.12.14", + "platform": "Linux" + }, + "runs": { + "native_base": { + "receipt": "evidence/NATIVE-BASE.json", + "coverage": "Fresh five stages after incomplete-descent negative-control fix." + }, + "native_extra": { + "receipt": "evidence/NATIVE-EXTRA.json", + "coverage": "Fresh five stages." + }, + "full_admission": { + "receipt": "evidence/ADMISSION.json", + "release": "evidence/RELEASE.json", + "coverage": "Complete strict supplier and modern outer; authenticated reuse of both fresh candidate native runs and existing pinned retained-parent/native evidence. Not an all-fresh retained-parent run." + }, + "portable_generator": { + "status": "PASS_REGENERATED_JOINT_TWELVE_BOTH_WORDS", + "log_sha256": "a0bf3febcc6f652f96a58d6b68a330148cf33943e2c1743d870d78e56865250f", + "coverage": "Authenticated PR2679 source; positive complete2462 reconstruction; both full semantic words regenerated." + }, + "public_wrapper": { + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE", + "coverage": "Explicit local pristine source and exact prepared native cache. Default remote-download/all-fresh path not executed end to end.", + "receipt": "evidence/PUBLIC-WRAPPER.json", + "seconds": 543.6799636979995, + "note": "The literal-review stage ran before final exact PR2745 comparison and claim-binding controls were added. The stronger final bounded checker was separately rerun successfully; full wrapper/admission code is unchanged." + }, + "registered": { + "status": "PASS_REGISTERED_RESEARCH_PACKAGE", + "coverage": "Python3.12 verify, generic ceiling, relocated/integrity tests.", + "log_sha256": "7363b02edab58b3f679677fb1e5a867ae83917f6cc537533e2c1301a7426a012" + } + }, + "initial_failures": [ + { + "run": "Initial base native local replay", + "finding": "Mutation construction assumed a nonzero intermediate centre destination. All-H8 word has none, raising StopIteration after positive replay. Replaced with actual incomplete nested descent, correctly repriced; fresh native run passed." + }, + { + "run": "Initial full word rebuild", + "finding": "Lowfour controls assumed old target135 and old source33 gate; alias653 position metadata was stale. Controls now select actual changed gates; regenerated literal metadata and reran original checks." + } + ], + "source_reuse": "REUSE-PINS.json authenticates every cache file; SOURCE-FILES.json authenticates original491 source files; overlay gives exact changed files and complete derived manifest. No selected frontier or upstream files modified.", + "formal_proof": false, + "independent_human_review": false, + "receipt_hashes": { + "evidence/ADMISSION.json": "b85b5b339353ae2a1935afa2963fcde7db9f66b41f205ddd632210257a8be168", + "evidence/INDEPENDENT.json": "f9e4500e5cb1ab1b9e8189de6dfbcca8dd9f7e2ea1a9ffce6801d6530797c0d2", + "evidence/NATIVE-BASE.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "evidence/NATIVE-EXTRA.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "evidence/OWNERS.json": "4df2066f097e4b59edf7d7af0e7e234413b9d2a09de4302d02adb3869972f672", + "evidence/PACKING-CAP.json": "59deb044b1b46953cbfd2fcedd3026a901d4524d7d05c592b8e1420501f6e652", + "evidence/PR2733-CLAIM.json": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "evidence/PR2745-CLAIM.json": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3", + "evidence/PUBLIC-WRAPPER.json": "70acee53d90097edfa3e7c99ad68311f236bade5ee71a446bcc8935e9e7e3192", + "evidence/RELEASE.json": "5839b3b3448d67d7a936fe962298d7d77cb83ee489321343af7769166f5d0142" + } +} diff --git a/research/t74-joint-twelve/FRESHNESS.json b/research/t74-joint-twelve/FRESHNESS.json new file mode 100644 index 0000000000..0bd23fd199 --- /dev/null +++ b/research/t74-joint-twelve/FRESHNESS.json @@ -0,0 +1,38 @@ +{ + "checked_utc": "2026-10-15T20:02:00.353190+00:00", + "scientific_base": "c22e42de697334df85337e005864773cdc2bc98b", + "fetched_canonical_main": "7ef5f7150476fdf995b286b9cdbed262c631939c", + "guidance": "AGENTS, CONTRIBUTING, autoresearch, family status, task catalogue, selected result and current status unchanged from base; review ledger updated with unrelated incorporation rounds. Frozen scientific inputs retained.", + "open_prs": { + "count": 727, + "highest_number": 2748, + "snapshot_sha256": "be5216931a74c4908760fbd33f0e044e2a832ccacf0bdc7e87c3ea9add291e51", + "coverage": "All open PR titles and bodies fetched (limit1000,727 returned); relevant latest construction heads and exact claims inspected. Not every code diff independently reviewed." + }, + "comparisons": [ + { + "pr": 2733, + "original_head": "2761b52b17590b8cf94f2e410004a8252d5592dc", + "latest_head": "19af796d8c158a07041e936747c27901e49c0bd2", + "claim": "Exact rational and profile unchanged." + }, + { + "pr": 2745, + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "claim": "Exact downloaded rational is strictly smaller than candidate; check in verify.py." + }, + { + "pr": 2720, + "head": "813fae623dcf3181fb9f535852ae4c82b1b369b5", + "claim": "Fixed-old-path obstruction. Current experiment changes that premise." + } + ], + "discussions": { + "coverage": "30 most recently updated discussion bodies and last15 comments of2612. Older discussions and arbitrary nested replies not exhaustively refreshed. No pinned issues returned.", + "snapshot_sha256": "de8819666de4704121286d0ba198ee5430b2d92505d9ce7830e933e931016ea7", + "coordination_sha256": "c81d3c18da42cb6ef7ef01f16e5d2aaf07eb717c1cf22d92cc44339afe1b34f9", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612", + "result_comment": "pending publication" + }, + "limitations": "No metadata search proves novelty. Earlier shell network failures and connector403 kept new scope claim local until publication." +} diff --git a/research/t74-joint-twelve/GENERATOR-PINS.json b/research/t74-joint-twelve/GENERATOR-PINS.json new file mode 100644 index 0000000000..53cbe5b14d --- /dev/null +++ b/research/t74-joint-twelve/GENERATOR-PINS.json @@ -0,0 +1,12 @@ +{ + "pr2679_manifest": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "vendor": { + "vendor/generate_words.py": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "vendor/gf_chart.py": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "vendor/target_transport.py": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "vendor/UPSTREAM-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "vendor/GENERATOR-NOTICE.txt": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "vendor/UPSTREAM-VENDOR-SOURCES.json": "592a98f6a3bd7fbd0063d90c989e30c5cd534220797b5b0beb0388e1f8d498ec", + "vendor/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } +} diff --git a/research/t74-joint-twelve/INPUT-PINS.json b/research/t74-joint-twelve/INPUT-PINS.json new file mode 100644 index 0000000000..3b928d7892 --- /dev/null +++ b/research/t74-joint-twelve/INPUT-PINS.json @@ -0,0 +1,17 @@ +{ + "inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11", + "inputs/FILL.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "inputs/POSITIVE2462-base.json.gz": "3506c84203f126900326ff4d22aaceda819734e5f96fa4622d43fbb78b946ece", + "inputs/POSITIVE2462-extra.json.gz": "ec7103c196b32de7af79a6f43952cbe998c085a00f1a8e740f5556c774589099", + "inputs/PROVIDERS.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06", + "inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7", + "inputs/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "inputs/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "evidence/PR2733-CLAIM.json": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "evidence/PR2745-CLAIM.json": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3" +} diff --git a/research/t74-joint-twelve/LICENSE b/research/t74-joint-twelve/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/t74-joint-twelve/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/t74-joint-twelve/OVERLAY-PINS.json b/research/t74-joint-twelve/OVERLAY-PINS.json new file mode 100644 index 0000000000..ec223bdbe2 --- /dev/null +++ b/research/t74-joint-twelve/OVERLAY-PINS.json @@ -0,0 +1,28 @@ +{ + "original_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "derived_manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "archive_sha256": "16468f7428c6e01522fcb15a8e3040d13de6cb8856428e32dcfbce8dbe46b8ec", + "files": { + "audit_mixed.py": "b8a319f580adf417384a13a996ca82ab674fae7917c2ae971aa4025bb2305e78", + "independent_core.py": "a747bf36a4c005398e71300005a5733bb9fa70fcdb0d00f306c894361c1b2a39", + "new/BORROW-PROVIDERS.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "new/borrow-fill/FILL.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "new/borrow-fill/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "new/borrow/inputs/alias1_43base.json": "20abad50afc6f75b01ba312687ef27c2ef3c41d8afc1429d8c8c8536384cf508", + "new/borrow/inputs/alias1_43extra.json": "df0739086556744574be9c574ae0cca3b1b7c1409d12647829999ffe9d3bed10", + "new/borrow/inputs/alias8_43base.json": "564a2576b3748847cbf5f0e9d22e4d96d159d65f654b5e02e317b05c186775dd", + "new/borrow/inputs/alias8_43extra.json": "9e437b3f6bd36f0e96bf41435a3698ffd42a17fb372492b144097bd59637d53c", + "new/borrow/inputs/lowfour_43base.json": "9f80e059f3b68eaf2682b162110a75091df98e73eb8d70fb442e5c6fad3363e7", + "new/borrow/inputs/lowfour_43extra.json": "9a726ea6bfd3c7d1452377e4be70ab986195ee184f82eb754906def0d08606fc", + "new/borrow/inputs/prelife_43base.json": "77a9a5e0fdfefe861171e46d370d0797356d99e1302d0b2c676d7a619804216d", + "new/borrow/inputs/prelife_43extra.json": "4b2a805cb82d0c8036d7217979ffe1ff984d29b399066585c6b2502597a386f9", + "new/borrow/inputs/refit563_43base.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/inputs/refit563_43extra.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/lowfour_controls.py": "157d05da7842ba3939290e874cc9f784f351cbfc897275aa1f19a500532ce89d", + "new/borrow/words/BORROW-WORD-43base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "new/rebuild_borrow.py": "2fa4035394be981d287a6e106a8af05d614704e6814fcebb9274b072a5cd03e2", + "MANIFEST.json": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf" + } +} diff --git a/research/t74-joint-twelve/PROFILE.json b/research/t74-joint-twelve/PROFILE.json new file mode 100644 index 0000000000..080d9e165d --- /dev/null +++ b/research/t74-joint-twelve/PROFILE.json @@ -0,0 +1,10 @@ +{ + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 +} diff --git a/research/t74-joint-twelve/PROOF.md b/research/t74-joint-twelve/PROOF.md new file mode 100644 index 0000000000..d2b1a96ba8 --- /dev/null +++ b/research/t74-joint-twelve/PROOF.md @@ -0,0 +1,25 @@ +# Changed recovery contract and complete moment + +The exact object is the two finite T74 words reconstructed by `generate.py`. The experiment uses a single explicit assignment, not a search over all assignments. Starting before PR2462's lowfour transformation is essential: applying the old lowfour patch first is a positive control reproducing its complete original words. + +The new `(removed helper, recovered source, partner)` assignments are: + +``` +(696,33,49), (697,55,101), (698,74,83), (700,85,98), +(680,49,33), (681,83,74), (682,98,85), (684,101,55), +(688,68,4), (689,80,88), (690,88,80), (692,31,12). +``` + +The last eight are PR2696's assignment. For each of the pairs33/49,55/101,74/83,85/98, let `(x,y)` denote the values after their last original uses, in their shared frame. The two added gates are `x += y/2` followed by `y -= x`, hence the linear map is `(x+y/2, y/2-x)`. For the actual predecessor state these restore the two original source values. The proof of that word-specific premise is the full arbitrary-input exact symbolic replay, not a claim that this map is the identity on arbitrary `(x,y)`. + +These restorations precede the new alias handoffs. Original operator IDs remain stable; twelve new chart transformations are appended. Removed-helper echoes are deleted only where they are target additions. For each new source, the generator computes the complete symbolic residual, transports its negative through precondition/compensation, and emits explicit initial correction gates and inverse source warps. Every residual must consist of a single new operator applied to its recovered source. Independent forward/dual propagation checks the resulting arbitrary-input identity, including dirty registers, and separately checks inverse cleanup. + +All lifted targets have frame `[45]`; their offsets are14,21,37,41,43,47,52,78,99,104,106,110. None is a target read by any cut gate. Actual frame propagation therefore leaves all eight centre children rank8. This changes the old-four recovery/target paths fixed in PR2720; its obstruction is respected within its stated domain. + +Apply the six PR2679 pre-life substitutions to the actual resulting state, refit the unique `515 += 563` gate (now B904), then alias653 into563. The complete generator checks semantic equality of both resulting words. The source-bound original checks and negative controls are rerun. No helper saving is inferred solely from nominal register labels. + +The complete local profile is `{1:2366,2:646,3:297,4:120,5:26,8:8}`. Compared with the PR2733 composition it changes by `4*(H8-H7-H1)` per local word. The same415-helper inventory admits the explicit complete allocation; `independent_owners.py` checks276390 roles, strict temporal windows, every physical cell, family masks and all remainders. There are666 call equivalents, giving global delta `2664*(H8-H7-H1)` and rank mass4816512 unchanged. + +At exponent `0= 1, 'positive logarithm range') + power = 0 + while x >= 2: + x /= 2 + power += 1 + a, b = log_reduced(x) + c, d = log_reduced(F(2)) + return a + power * c, b + power * d + + +def exp_bounds(x): + """Taylor terms 0..15; later term ratios are bounded by x/17.""" + require(0 <= x < F(1, 100), 'exponential argument range') + term, lower = F(1), F(1) + for n in range(1, 16): + term = term * x / n + lower += term + tail = term * x / 16 / (1 - x / 17) + return lower, lower + tail + + +def moment_bounds(profile, exponent): + lower = upper = F(0) + for rank, count in sorted(profile.items()): + log_lo, log_hi = log_bounds(F(DIMENSION, rank)) + exp_lo, _ = exp_bounds(exponent * log_lo) + _, exp_hi = exp_bounds(exponent * log_hi) + weight = F(count * rank, DIMENSION) + lower += weight * exp_lo + upper += weight * exp_hi + return lower, upper diff --git a/research/t74-joint-twelve/full_replay.py b/research/t74-joint-twelve/full_replay.py new file mode 100644 index 0000000000..d9718b8b5b --- /dev/null +++ b/research/t74-joint-twelve/full_replay.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Cold reproduction of the joint twelve-source/pre-life composition. + +Default: authenticated source download, fresh native providers and retained +parent admission, then the complete original supplier/release verifier. An +explicit --prepared-native-cache must match every published reuse file hash. +All large/generated artifacts remain under a fresh external --work directory. +""" +import argparse +from concurrent.futures import ThreadPoolExecutor +from fractions import Fraction as Q +import gzip +import hashlib +import importlib +import json +import os +from pathlib import Path, PurePosixPath +import platform +import shutil +import subprocess +import sys +import tarfile +import threading +import time +from urllib.parse import quote +from urllib.request import Request, urlopen + +HERE = Path(__file__).resolve().parent +REPOSITORY = HERE.parents[1] +STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unauthenticated symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def safe(name): + path = PurePosixPath(name) + need(isinstance(name, str) and '\\' not in name and path.parts and not path.is_absolute() + and '..' not in path.parts and path.as_posix() == name, 'unsafe source path') + + +def download(url, expected): + for attempt in range(3): + try: + req = Request(url, headers={'User-Agent': 'integer-mult-prelife-priority/1', 'Accept-Encoding': 'identity'}) + with urlopen(req, timeout=90) as response: + body = response.read() + need(hashlib.sha256(body).hexdigest() == expected, 'download hash mismatch') + return body + except (OSError, RuntimeError): + if attempt == 2: + raise + time.sleep(attempt + 1) + + +def source_copy(source, destination, pins, jobs): + destination.mkdir() + entries = {'MANIFEST.json': pins['manifest_sha256'], **pins['files']} + need(len(pins['files']) == pins['count'] == 491, 'source file count') + + def copy(item): + name, digest = item + safe(name) + target = destination / name + target.parent.mkdir(parents=True, exist_ok=True) + if source: + need(not (source / name).is_symlink(), 'source symlink') + body = (source / name).read_bytes() + need(hashlib.sha256(body).hexdigest() == digest, 'source bytes: ' + name) + else: + body = download(pins['base_url'] + quote(name, safe='/'), digest) + target.write_bytes(body) + + with ThreadPoolExecutor(max_workers=min(jobs, 8)) as pool: + for _ in pool.map(copy, sorted(entries.items())): + pass + need(read(destination / 'MANIFEST.json') == pins['files'] + and tree(destination) == entries, 'complete source authentication') + + +def bind_native(entry, word): + need(gzip.decompress((entry / 'local/FULL-WORD.json.gz').read_bytes()) == gzip.decompress(word.read_bytes()), + 'native complete word binding') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == STEPS and all(s['exit_code'] == 0 for s in stages), 'native stage coverage') + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--source', type=Path, help='Exact original PR2679 package directory; otherwise download pinned files.') + ap.add_argument('--work', type=Path, required=True) + ap.add_argument('--prepared-native-cache', type=Path, help='Explicit reuse of the complete published pinned cache.') + ap.add_argument('--jobs', type=int, default=4) + a = ap.parse_args() + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + versions = {} + for name in ('numpy', 'sympy', 'scipy', 'mpmath'): + try: + versions[name] = str(importlib.import_module(name).__version__) + except ImportError as exc: + raise RuntimeError('install requirements.txt in this Python environment before full replay') from exc + need(versions['sympy'] == '1.14.0', 'pinned predecessor evidence requires sympy==1.14.0') + work = a.work.resolve() + need(not work.exists() and not work.is_relative_to(REPOSITORY), 'fresh external work required') + for path in (a.source, a.prepared_native_cache): + need(path is None or (path.is_dir() and not work.is_relative_to(path.resolve())), 'input/work separation') + pins, reuse, claim = read(HERE / 'SOURCE-FILES.json'), read(HERE / 'REUSE-PINS.json'), read(HERE / 'CLAIM.json') + work.mkdir(parents=True) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1') + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, lock = [], threading.Lock() + started = time.monotonic() + + def run(name, script, *args): + begin = time.monotonic() + log = work / (name + '.log') + command = [sys.executable, '-B', str(script), *map(str, args)] + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + with lock: + stages.append(dict(name=name, command=command, exit_code=result.returncode, + script_sha256=sha(script), seconds=time.monotonic()-begin, log_sha256=sha(log))) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + run('literal-review', HERE / 'verify.py') + source = work / 'source' + source_copy(a.source.resolve() if a.source else None, source, pins, a.jobs) + overlay = read(HERE / 'OVERLAY-PINS.json') + need(sha(source/'MANIFEST.json') == overlay['original_manifest_sha256'], 'overlay base manifest') + need(sha(HERE/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive') + with tarfile.open(HERE/'DERIVATIVE-OVERLAY.tar.gz') as archive: + members=archive.getmembers() + need(set(m.name for m in members)==set(overlay['files']) and len(members)==len(overlay['files']), 'exact overlay paths') + for member in members: + safe(member.name);need(member.isfile(), 'regular overlay file') + body=archive.extractfile(member).read() + need(hashlib.sha256(body).hexdigest()==overlay['files'][member.name], 'overlay member hash') + (source/member.name).write_bytes(body) + need(sha(source/'MANIFEST.json')==overlay['derived_manifest_sha256'] and + tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'), 'complete derived source tree') + pins=dict(pins,commit='local-joint12-pr2733',manifest_sha256=overlay['derived_manifest_sha256']) + cache = work / 'native-cache' + if a.prepared_native_cache: + need(tree(a.prepared_native_cache.resolve()) == reuse['cache_files'], 'published complete cache pins') + shutil.copytree(a.prepared_native_cache.resolve(), cache) + native_receipt = reuse + else: + cache.mkdir() + layout = work / 'retained-layout' + layout.mkdir() + old = source / 'vendor/pr1297' + with tarfile.open(old / 'upstream-layout.tar.gz') as archive: + need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + for m in archive.getmembers()), 'retained archive paths') + archive.extractall(layout, filter='data') + retained_driver = layout / 'joint1148-round45/source/research/k8-eight-ends/replay_native.py' + words = {'base': source / 'new/borrow/words/BORROW-WORD-43base.json.gz', + 'extra': source / 'new/borrow/words/BORROW-WORD-43extra.json.gz', + 'retained-base': old / 'gauge44-word.json.gz', 'retained-extra': old / 'extra-word.json.gz'} + + def fresh_native(tag): + word = words[tag] + entry = cache / sha(word) + script = retained_driver if tag.startswith('retained-') else source / 'new/run_native_borrow.py' + run('native-' + tag, script, word, entry) + bind_native(entry, word) + write(entry / 'CACHE.json', dict(word_sha256=sha(word), files=tree(entry))) + + with ThreadPoolExecutor(max_workers=min(a.jobs, 4)) as pool: + for _ in pool.map(fresh_native, words): + pass + run('retained-parent', old / 'verify.py', '--work', work / 'retained-parent', + '--base-native-from', cache / sha(words['retained-base']), + '--extra-native-from', cache / sha(words['retained-extra'])) + parent = read(work / 'retained-parent/RESULT.json') + need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'fresh retained parent admission') + pm = sha(old / 'MANIFEST.json') + receipts = cache / '_receipts' / pm + receipts.mkdir(parents=True) + for name in ('RESULT.json', 'STAGES.json'): + shutil.copy2(work / 'retained-parent' / name, receipts / name) + write(receipts / 'RECEIPT.json', dict(schema='parent-receipt/1', vendor_manifest_sha256=pm, + claim_sha256=sha(old / 'CLAIM.json'), words={tag:sha(words['retained-'+tag]) for tag in ('base','extra')}, + files={name:sha(receipts / name) for name in ('RESULT.json','STAGES.json')})) + providers = {tag:dict(word_sha256=sha(words[tag]), complete_native_files=tree(cache / sha(words[tag]), ('CACHE.json',))) + for tag in ('base','extra')} + native_receipt = dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE', + source_commit=pins['commit'], manifest_sha256=pins['manifest_sha256'], providers=providers, + retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), cache_files=tree(cache)) + write(work / 'NATIVE-RECEIPT.json', native_receipt) + run('complete-admission', HERE / 'workflow/admit.py', '--source', source, + '--fill', HERE / 'inputs/FILL.json.gz', '--order', HERE / 'inputs/ORDER.json', + '--native-cache', cache, '--native-receipt', work / 'NATIVE-RECEIPT.json', + '--work', work / 'admission', '--jobs', a.jobs) + result = read(work / 'admission/RESULT.json') + need(result['status'] == 'PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE' + and Q(result['kappa']) == Q(claim['kappa']) and Q(result['complex_lower']) == Q(claim['complex_lower']), + 'published complete claim binding') + need(result['profile'] == {str(k):v for k,v in read(HERE / 'CLAIM.json')['profile'].items()}, 'published complete profile binding') + result.update(status='PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache), + source_files_sha256=sha(HERE / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'), + cold_stages=stages, cold_seconds=time.monotonic()-started, + environment=dict(python=platform.python_version(), executable=sys.executable, versions=versions)) + write(work / 'RESULT.json', result) + print(result['status'], result['kappa_decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve/generate.py b/research/t74-joint-twelve/generate.py new file mode 100644 index 0000000000..82ca3d20a5 --- /dev/null +++ b/research/t74-joint-twelve/generate.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Rebuild the changed twelve-alias word and PR2679 pre-life/refit composition. +Pristine source is authenticated; only a fresh output directory is written. +""" +from pathlib import Path +import argparse,copy,gzip,hashlib,json,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import joint_engine as J +ASSIGNMENTS=[(696,33,49),(697,55,101),(698,74,83),(700,85,98),(680,49,33),(681,83,74),(682,98,85),(684,101,55),(688,68,4),(689,80,88),(690,88,80),(692,31,12)] +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def wr(p,w):p.write_bytes(gzip.compress((json.dumps(w,sort_keys=True,separators=(',',':'))+'\n').encode(),mtime=0)) +def main(): + need(__debug__,'assertions must be enabled') + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + source=a.source.resolve();out=a.out.resolve();pins=rd(HERE/'GENERATOR-PINS.json') + sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() + need(sha(source/'MANIFEST.json')==pins['pr2679_manifest'],'PR2679 source manifest') + need(all(sha(source/k)==v for k,v in rd(source/'MANIFEST.json').items()),'complete source files') + need(all(sha(HERE/k)==v for k,v in pins['vendor'].items()),'vendor sources') + need(not out.exists() and not out.is_relative_to(source),'fresh separate output required');out.mkdir(parents=True) + S=source/'new/borrow';sys.path[:0]=[str(S),str(S/'prelife/search')] + import build_word,word_patch as W,prelife2 as P,repair2,alias_build as AB,audit_local as AU + for canon,tag,h in [('gauge44','base','eeb6a236'),('extra','extra','cd417b90')]: + f=out/f'canonical-{tag}.json.gz';build_word.main(str(S/f'inputs/{canon}.canonical.json.gz'),str(S/'inputs/blocks.json'),str(S/f'inputs/witness_43_{tag}.json'),str(f),h);w=rd(f) + patch=rd(S/f'inputs/refit_43{tag}.json') + for sec,i,frame in patch['frames']:w[sec][i][-1]=frame + w['report']['local_profile']=patch['local_profile'];w['cleanup']=W.derive_cleanup(w,W.restored_of(w)) + w=W.apply_kernel(w,rd(S/f'inputs/kernel_43{tag}.json')) + for name in ['handoff','entrance']:w=W.apply_handoff(w,rd(S/f'inputs/{name}_43{tag}.json')) + need(W.apply_lowfour(w,rd(S/f'inputs/lowfour_43{tag}.json'))==rd(HERE/f'inputs/POSITIVE2462-{tag}.json.gz'),'complete PR2462 positive reconstruction') + w['prelude_events']=0;w=J.make(source,out/'joint',tag,seed=w,assignments=ASSIGNMENTS) + patch=rd(S/f'inputs/prelife_43{tag}.json') + for pair in patch['pairs']: + host,borrower=pair['h'],pair['L'];E=next(x[4] for x in patch['fields']['warps'][58:] if x[1]==host) + P.TRACE,_=repair2.run(copy.deepcopy(w),None);w=P.build(w,borrower,host,E) + indices=[i for i,g in enumerate(w['B']) if g[:5]==['add',515,563,1,1]];need(len(indices)==1,'unique refit gate') + w['B'][indices[0]][-1]=rd(S/f'inputs/refit563_43{tag}.json')['frames'][0][-1] + w,_=AB.alias(w,653,563);lp,wi=AB.profile(w);w['report'].update(local_profile=lp,width_inventory=wi) + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated word equality') + print('PASS_REGENERATED_JOINT_TWELVE_BOTH_WORDS') +if __name__=='__main__':main() diff --git a/research/t74-joint-twelve/independent_local.py b/research/t74-joint-twelve/independent_local.py new file mode 100644 index 0000000000..e0b556adc3 --- /dev/null +++ b/research/t74-joint-twelve/independent_local.py @@ -0,0 +1,161 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Mason Hale/Codex PR2696 literal replay, extended by Tekalign/Codex. +Adds anticipatory corrections, checks six pre-life hosts and checks all twelve +source-recovery assertions at operator IDs47 through58. +""" +import json,gzip,hashlib +from collections import Counter,defaultdict +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +@lru_cache(None) +def span(vs): + s={0} + for v in vs:s|={x^v for x in tuple(s)} + return frozenset(s) +def S(vs):return span(tuple(vs)) +def rank(vs):return len(S(vs)).bit_length()-1 +def dm(s):return len(s).bit_length()-1 +FULL=S([1<>i&1:a^=c + return a +def regs(g):return g[1:3] if g[0]=='add' else g[1:2] +def nt(r):return not 112<=r<224 +def load(p):return json.loads(gzip.decompress(p.read_bytes())) +def chronological(w): + d=defaultdict(list) + for op,(p,r,*_) in enumerate(w['warps'],1):d[p].append(['warp',r,op]) + b=[] + for i in range(len(w['B'])+1): + b+=d[i] + if i0 else (new,old) + assert frozenset(im(cols,x) for x in S(a))==S(b) + cur[r]=S(new) + for g in w['A']: + if g[0]=='warp':warp(*g[1:]) + else: + for r in regs(g):climb(r,g[-1]) + bysection['A']=dict(counts);prev=counts.copy() + lev={int(k):S(v) for k,v in w['target_levels'].items()} + assert all(cur[112+t]==lev.get(t,S([])) for t in range(112)) + paths=[] + for r,vs in zip(w['centers'],w['center_frames']): + s=S(vs);assert cur[r]==s + targets=[g[1]-112 for g in w['cut'] if g[2]==r] + frames=sorted({lev.get(t,S([])) for t in targets},key=lambda s:-len(s)) + ds=[] + for f in frames: + assert f<=s + d=dm(s)-dm(f) + if d:counts[d]+=1;ds.append(d) + s=f + paths.append({'center':r,'start_rank':rank(vs),'target_offsets':targets,'reader_lines':[sorted(f-{0}) for f in frames],'paid_degrees':ds}) + bysection['cut']=dict(counts-prev);prev=counts.copy() + ops=defaultdict(list) + for op,rec in enumerate(w['warps'],1):ops[rec[0]].append((op,rec)) + for i in range(len(w['B'])+1): + for op,(_,r,cols,old,new) in ops[i]:warp(r,op,old,new) + if i=224) + assert counts==Counter({int(k):v for k,v in w['report']['local_profile'].items()}) + assert inventory==Counter({int(k):v for k,v in w['report']['width_inventory'].items()}) + return {'profile':dict(sorted(counts.items())),'section_profiles':bysection,'inventory':dict(sorted(inventory.items())),'center_paths':paths},start,ends + +def check_cleanup(w): + restored=set(map(int,w['helper_final'])) + cold=lambda r:r+704 if r in restored else r + forward=w['A'][w['prelude_events']:]+chronological(w)+w['restore'] + expected=[] + for g in reversed(forward): + if g[0]=='warp':expected.append(['warp',cold(g[1]),-g[2]]) + elif nt(g[1]): + if g[0]=='add':expected.append(['add',cold(g[1]),cold(g[2]),-g[3],g[4]]) + else:expected.append(['scale',cold(g[1]),g[3],g[2]]) + assert expected==[g[:-1] for g in w['cleanup']] + assert all(S(g[-1])==FULL for g in w['cleanup']) + return len(expected) + +def algebra(w): + # A monomial records its operations oldest-first; appending an inverse + # cancels the newest symbol. No native/generator/audit modules imported. + live=set(range(704))-set(w['removed']);cold=set(map(int,w['helper_final'])) + assert all(112<=x['target']<224 and x['source'] in {273,275,289,291,305,321} for x in w['initial_corrections']) + program=[['correction',x] for x in w['initial_corrections']]+w['precondition']+w['compensation']+w['A']+w['cut']+chronological(w)+w['restore'] + result={} + for dual in [False,True]: + rows={r:{(r,()):F(1)} for r in live} + rows.update({704+r:{} for r in cold}) + def apply(g): + op=g[0] + if op=='correction': + x=g[1];t,s=x['target'],x['source'];q=F(x['coefficient']) + ops=list(reversed(x['operator_word'])) + if dual: + t,s,q=s,t,-q + ops=[-(abs(v)+1000)*(1 if v>0 else -1) for v in x['operator_word']] + for (r,word),c in list(rows[s].items()): + for v in ops:word=word[:-1] if word and word[-1]==-v else word+(v,) + key=(r,word);value=rows[t].get(key,F(0))+q*c + if value:rows[t][key]=value + else:rows[t].pop(key,None) + elif op=='add': + t,s=g[1:3];q=F(g[3],g[4]);assert t!=s + if dual:t,s,q=s,t,-q + for term,c in list(rows[s].items()): + v=rows[t].get(term,F(0))+q*c + if v:rows[t][term]=v + else:rows[t].pop(term,None) + elif op=='scale': + q=F(g[2],g[3]);q=1/q if dual else q + rows[g[1]]={term:q*c for term,c in rows[g[1]].items()} + elif op=='warp': + d=g[2] + if not dual and 460 else -1) + rows[g[1]]={(r,word[:-1] if word and word[-1]==-d else word+(d,)):c for (r,word),c in rows[g[1]].items()} + else:raise AssertionError(op) + for g in program:apply(g) + if not dual: + assert all(rows[112+t]=={(112+t,()):F(1),(t,()):F(1)} for t in range(112)) + assert all(rows[r]=={(r,()):F(1)} for r in cold) + assert all(not any(var in cold-{r} for (var,word) in rows[r]) for r in live) + for g in w['cleanup']:apply(g) + for r in live: + exp={(r,()):F(1)} + if dual and r<112:exp[(112+r,())]=F(-1) + if not dual and 112<=r<224:exp[(r-112,())]=F(1) + assert rows[r]==exp,(dual,r,rows[r]) + assert all(not rows[704+r] for r in cold) + result['dual' if dual else 'forward']='PASS' + return result diff --git a/research/t74-joint-twelve/independent_owners.py b/research/t74-joint-twelve/independent_owners.py new file mode 100644 index 0000000000..93270b725a --- /dev/null +++ b/research/t74-joint-twelve/independent_owners.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Independent integer-time chronology and bit-mask whole-fill verification. + +No retained window code, donor generator, solver or native checker is imported. +Credit PR2679's pre-life/refit words, PR2673/PR2621 priority scheduling, +PR2588's swapped words, PR2559's evacuation, PR2530's source-partner +fill and the PR2462/PR2322/PR2436 lineage; +Hao Yan and the retained controller authors supply the underlying schedule. +This checks a finite hosting witness, not native circuitry or an exponent. +""" +import argparse +import sys +sys.dont_write_bytecode=True +import gzip +import hashlib +import json +from collections import Counter +from pathlib import Path + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def windows(template, order): + ranks={c['child']:c['rank'] for c in template['idle_children']} + pairs={e['stage']:e['pair'] for e in template['recipe'] if e['kind']=='local'} + blocks={};stage=None + for event in template['execution_schedule']: + if event['kind'] in ('bank_padding_cover_sweep','translate_every_live_family'): + continue + if event['kind']=='local_cover_sweep': + stage=event['stage'];blocks[stage]=[] + need(stage is not None,'event before first call') + blocks[stage].append(event) + progression=[0]*74;last={};result={} + for t,(stage,replica) in enumerate(order): + need(0<=replica<74 and stage==progression[replica],'order chronology') + progression[replica]+=1 + for j,event in enumerate(blocks[stage]): + kind=event['kind'] + if kind=='local_cover_sweep': + need(j==0,'local call position') + last[replica,pairs[stage]]=t + elif kind=='bridge': + last[replica,event['src']]=last[replica,event['dst']]=t + elif kind=='idle_cover_sweep': + need(j>0,'idle position') + start=last.get((replica,event['pair']),-1) + for child in event['child_indices']: + if child in ranks: + result[replica,child]=(ranks[child],start,t) + need(progression==[9]*74,'complete replica progression') + return result + + +def check(plan, template, order, fill, providers, initial_dispatch, expected_profile): + need(len(order)==666 and len(set(map(tuple,order)))==666,'call coverage') + win=windows(template,order) + dispatch=dict(initial_dispatch) + for s,r,pid in fill['dispatch_overrides']: + need((s,r) in dispatch and pid in providers,'dispatch override') + dispatch[s,r]=pid + need(set(dispatch)==set(map(tuple,order)),'dispatch coverage') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns') + need(len(fill['rows'])==666*415,'role count') + need(all(len(p['widths'])==415 for p in providers.values()),'helper widths') + helper_bits=[0]*666;family_bits=[0]*666;occupied={} + for row in fill['rows']: + need(len(row)==6 and all(type(v) is int for v in row),'role shape') + t,h,o,c,port,offset=row + need(0<=t<666 and 0<=h<415 and 0<=port<112,'role bounds') + cap,start,stop=win[o,c] + need(startlen(a):a.append(x) + for x in F: + if len(b)len(b):b.append(x) + assert len(a)==len(b)==4 + cols=C.gf_change(a,b,9);E=[C.gf_linear(cols,x) for x in U] if hasattr(C,'gf_linear') else [G.mapped(cols,x) for x in U] + op=len(w['warps'])+len(newrecords)+1;newrecords.append([first,r,cols,list(U),E]);replace[h]=r + nw['removed'].append(h);del nw['start_extra'][str(h)];nw['helper_final'].pop(str(h),None) + # Keep preexisting operator IDs stable; extra warps are appended to the table. + newB=[];position={} + for i in range(len(w['B'])+1): + newB.extend(before[i]);position[i]=len(newB) + if ilen(w['warps']),(t,r,op,q) + groups[r,op[0]][t]=-q + prelude=[];targetlines={} + for (r,op),coeff in groups.items(): + for g in nw['precondition']+nw['compensation']:coeff=step(coeff,g,set(range(112,224))) + record=nw['warps'][op-1];line=[G.mapped(record[2],w['ports'][r])] + for t in coeff: + assert t not in targetlines or targetlines[t]==line,(t,r,op,line,targetlines.get(t),dict(groups)) + targetlines[t]=line + prelude.append(['warp',r,op,[w['ports'][r]],line]) + for t,q in sorted(coeff.items()):prelude.append(['add',t,r,q.numerator,q.denominator,line]) + prelude.append(['warp',r,-op,line,[w['ports'][r]]]) + lifts=[] + for t,line in sorted(targetlines.items()): + key=str(t-112);old=nw['target_levels'].get(key,[]);assert not old or G.basis(old)==G.basis(line) + if not old:lifts.append(['scale',t,1,1,line]);nw['target_levels'][key]=line + nw['A']=lifts+prelude+nw['A'];nw['prelude_events']+=len(lifts)+len(prelude) + tmp=copy.deepcopy(nw);tmp['A']=tmp['A'][nw['prelude_events']:];nw['cleanup']=WP.derive_cleanup(tmp,WP.restored_of(w)) + pp,iv=paid_lifted(nw);nw['report']['local_profile']=pp;nw['report']['width_inventory']=iv + out=BASE/f'eight-alias-{tag}.json.gz';out.write_bytes(gzip.compress(json.dumps(nw,separators=(',',':')).encode())) + print('BUILT',tag,'newops',len(newrecords),'targets',targetlines,'file',out,flush=True) + AU2.run(out,BASE/f'eight-alias-{tag}-audit.json') + return nw diff --git a/research/t74-joint-twelve/packing_cap.py b/research/t74-joint-twelve/packing_cap.py new file mode 100644 index 0000000000..dd97566afb --- /dev/null +++ b/research/t74-joint-twelve/packing_cap.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Uses Douglas Colkitt's exact ceiling engine (Claude-assisted), pinned unchanged. +# Adapter by Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Fixed-word coverage-law ceiling; separate from physical and outer admission.""" +import argparse, hashlib, importlib.util, json, sys +from fractions import Fraction as Q +from decimal import Decimal, localcontext +from pathlib import Path +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +IDLE = {1:17316,3:6594,5:5216,32:1,48:26558} +CANDIDATE = {1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +ENDPOINT = Q('0.001717141586348426338109') + +def need(ok, message): + if not ok: + raise ValueError(message) + +def calculate(profile_path=None): + path = HERE / 'vendor/ceiling.py' + need(hashlib.sha256(path.read_bytes()).hexdigest() == ENGINE_SHA, 'ceiling source pin') + spec = importlib.util.spec_from_file_location('packing_ceiling', path) + engine = importlib.util.module_from_spec(spec); spec.loader.exec_module(engine) + h = {int(r): n for r,n in json.loads((profile_path or HERE/'PROFILE.json').read_text()).items()} + need(h == CANDIDATE and sum(r*n for r,n in h.items()) == 4816512, + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} + need(local == {1:2366,2:646,3:297,4:120,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) + need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5223, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') + c = Q(json.loads((HERE/'CLAIM.json').read_text())['complex_lower']) + need(c == ENDPOINT, 'certified candidate endpoint') + with localcontext() as ctx: + ctx.prec = 50 + dec = lambda x: str(Decimal(x.numerator)/Decimal(x.denominator)) + return dict(status='PASS_FIXED_WORD_PACKING_CEILING',source_sha256=ENGINE_SHA, + local_per_call={str(r):str(n) for r,n in local.items()}, + dimension=73,families=896,stages=9,centre_rank_per_call=64,max_idle_rank=model['R'], + complex_cap_bracket=[str(lo),str(hi)],complex_cap_upper_decimal=dec(hi), + realized_fraction_lower=str(c/hi),realized_fraction_decimal=dec(c/hi), + scope='Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used.') + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--output',type=Path) + ap.add_argument('--profile',type=Path,default=HERE/'PROFILE.json');a=ap.parse_args() + text=json.dumps(calculate(a.profile),indent=2)+'\n' + if a.output: + a.output.parent.mkdir(parents=True,exist_ok=True);a.output.write_text(text) + print(text,end='') +if __name__=='__main__': main() diff --git a/research/t74-joint-twelve/requirements.txt b/research/t74-joint-twelve/requirements.txt new file mode 100644 index 0000000000..816d0c8e91 --- /dev/null +++ b/research/t74-joint-twelve/requirements.txt @@ -0,0 +1,4 @@ +numpy==2.5.4 +sympy==1.14.0 +scipy==1.18.1 +mpmath==1.3.0 diff --git a/research/t74-joint-twelve/test_integrity.py b/research/t74-joint-twelve/test_integrity.py new file mode 100644 index 0000000000..73c4e96005 --- /dev/null +++ b/research/t74-joint-twelve/test_integrity.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Git-free read-only replay and fail-closed input/claim/optimization controls.""" +import hashlib,json,os,shutil,subprocess,sys,tempfile +from pathlib import Path +HERE=Path(__file__).resolve().parent +def need(ok,msg): + if not ok:raise RuntimeError(msg) +def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} +def main(): + with tempfile.TemporaryDirectory(prefix='joint-twelve-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) + r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') + f=p/'CLAIM.json';b=f.read_bytes();c=json.loads(b);c['kappa']='1';f.write_text(json.dumps(c));r=run();need(r.returncode!=0 and 'claim outer endpoint' in r.stderr,'claim corruption rejection');f.write_bytes(b) + f=p/'inputs/WORD-base.json.gz';b=f.read_bytes();f.write_bytes(b+b'corruption');r=run();need(r.returncode!=0 and 'input digest' in r.stderr,'word authentication rejection');f.write_bytes(b) + need(hashes(p)==before,'controls restore exact files') + print('PASS_JOINT_TWELVE_RELOCATED_READ_ONLY_AND_INTEGRITY_CONTROLS') +if __name__=='__main__':main() diff --git a/research/t74-joint-twelve/vendor/GENERATOR-NOTICE.txt b/research/t74-joint-twelve/vendor/GENERATOR-NOTICE.txt new file mode 100644 index 0000000000..b075f7180e --- /dev/null +++ b/research/t74-joint-twelve/vendor/GENERATOR-NOTICE.txt @@ -0,0 +1,129 @@ +Generator for PR2312 width exchange plus coherent four-handoff transformation +========================================================================== + +generate_words.py is new portable code prepared with substantial AI +assistance, under the repository Apache-2.0 license. It directly transforms +the pinned PR2312 width-exchange BORROW-WORDs and regenerates cleanup. The existing source +builder is not copied or imported at runtime. The independent native chain, +rather than the generator or its hashes, proves all-column circuit correctness +and exact physical Clifford phases. + +PR2312 width exchange is credited to Jeremy Kothe (@jeremykothe2), with +AI assistance: alias 651 is re-lent from lender 530 and alias 653 is dropped, +freeing register 554 for cold restoration and changing two width-8 helpers +to width 7. The exact frame re-solve of both borrowed words and the owner +fill for that source width inventory retain the source's credit to Jeremy +Kothe, with AI assistance. This generator consumes the resulting complete +source words; it does not reapply their kernels or width exchange. + +Consumed PR2312 source head: + fb76f799ccf078f51780076ebed3fd26b1db11c0 +Package: + research/gmx-t74-borrow43-width-exchange +Manifest SHA-256: + c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313 + +The two helper-donor kernels at pivots 518 and 506 are retained from +PR2302. Their kernel shape is credited to mdumitrean (PR1625); their search, +exact pricing and frame re-solve are credited to Jeremy Kothe +(@jeremykothe2), with AI assistance, as stated by the source. The PR2302 +source and this necessary derivative generator were prepared with AI +assistance. This generator composes the four block-616 handoffs after those +kernels, preserving all kernel scalar gates and their re-solved frames. + +Predecessor PR2302 source head: + d520b92d7bf18efcb7d84f12757face6fe9541f1 +Package: + research/gmx-t74-borrow43-k518-506 +Manifest SHA-256: + 74634d13d27026e2867973b58dfef5e31958d92c54454b29e52292b7fc2e1f0d + +WildIdeas is credited for the exact frame refits retained from PR2288. +The source's additional frame-solver credit to Jeremy Kothe, with AI +assistance, is retained. The predecessor's full credit and licensing notice +is reproduced below. + +Anticipatory dirty borrowing is credited first to Cinna Davis +(@1337isnot1337), PR2226, with substantial OpenAI Codex assistance. The +retired-register K_G handoff and inverse-reverse FULL cleanup with proper-ended +private zero buffers derive from that construction and its PR2288 realization. +PR2288 source head: 614c74a63b0f6d4a24c7740d7ddb90d37861b3c7. + +This code is licensed under Apache-2.0, inherited from the repository. +The original repository LICENSE and NOTICE remain in the predecessor source; +the consumed package NOTICE is reproduced verbatim below, along with the +additional PR2226 notice. The PR2312 and PR2302 package NOTICE files are byte-identical to the +PR2288 package NOTICE reproduced here. + +--- PR2288 package NOTICE (verbatim) --- + +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. + + +--- PR2226 native-chain notice (verbatim) --- + +# Credit: anticipatory dirty borrowing (PR2226) + +The construction realised by this native chain is **PR2226, "anticipatory dirty borrowing"**, by Cinna Davis +(@1337isnot1337), prepared with substantial OpenAI Codex assistance (Apache-2.0): the logical reference change +K_G of a lender register (a monomial Clifford: a permutation of the 512 columns with phase mod 4), the initial +compensation terms c K_G z, the early cold tail, the exact cold restoration and the private zero buffers of the +FULL-frame cleanup. `vendor/pr2226_operators.py`, `vendor/pr2226_replay.py` and `vendor/PR2226-NOTICE.md` are byte copies +of PR2226's `operators.py`, `replay.py` and `NOTICE.md`. `bw_gauss.py` is a port of `operators.py` (change, monomial, +apply_mono, coord, frame, check) and adds a decoder from a serialized `clifford_exact` monomial to its exact 512 x 512 +Gaussian matrix. + +What this chain adds (the P3 native realisation, with the Borrow campaign's explicit chronological BORROW-WORD as input): +warp events and zero buffers in `LOCAL-PROGRAMS`, warp recipes in `CLIFFORD-RECIPES.json` (lowered with the unchanged +`lower_child`, rank zero, then compared with the exact numpy column product), logical K_G recipes in +`RESIDUAL-ADAPTERS.json`, an independent local replay in both orientations that checks every warp product on all 512 +columns, and the negative controls listed in `INDEPENDENT-LOCAL-REPLAY.json`, `WRAPPER-CHECKS.json`, `WARP-RECIPE-CHECKS.json` +and `bw_tamper.py`. + +Lineage retained: icekylinx (PR425/433/514, scalar and wrapper machinery), DreamingOfClouds (PR458/484/593 hyperplane/cold-HPE +extensions), the clifford_exact compiler (vendor531), and the owners named in the package README. `vendor/clifford/clifford_exact.py` +is a byte copy. + + +Reproduction and equality +======================== + +Run: + python3 generate_words.py --source-root FETCHED_REPOSITORY --out NEW_DIRECTORY + +The generator checks the pinned source manifest and both consumed compressed +source-word hashes. It writes base.json.gz, extra.json.gz and GENERATION.json. +Canonical JSON hashes cover every output field, including frames, scalar +gates, operators, endpoints, cleanup and invoices. These hashes determine +regenerated circuit equality. The compressed container hashes are recorded +for provenance; Python/zlib changes can produce different gzip streams for +the same circuit. The OS header byte is normalized to 255. In the recorded generation +environment both output containers also exactly match the composed +word hashes. Recompression alone does not require repeating native phases. + +The four binary G maps are explicit construction constants, checked for +invertibility and the measured source-to-handoff chart identity on each run. +The native replay independently lowers their exact physical representatives. +Two old warp-basis representatives are rewritten only after verifying equal +GF(2) spans, preserving the frozen input serialization. No JSON patch file or +unrecorded local dependency is needed. + +Composition binding +=================== + +The source-manifest and source-word constants bind the consumed PR2312 +inputs. The canonical JSON target hashes cover every composed output field. +The literal base tag names PR2312 width exchange plus coherent joint616; +SOURCE_COMMIT and SOURCE_MANIFEST identify the consumed source. +This generation receipt does not establish native phases, owner admission, +or a new exponent; those require their separate independently replayed +native and global receipts. diff --git a/research/t74-joint-twelve/vendor/LICENSE b/research/t74-joint-twelve/vendor/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/t74-joint-twelve/vendor/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/t74-joint-twelve/vendor/UPSTREAM-NOTICE b/research/t74-joint-twelve/vendor/UPSTREAM-NOTICE new file mode 100644 index 0000000000..46411b80b2 --- /dev/null +++ b/research/t74-joint-twelve/vendor/UPSTREAM-NOTICE @@ -0,0 +1,10 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. diff --git a/research/t74-joint-twelve/vendor/UPSTREAM-VENDOR-SOURCES.json b/research/t74-joint-twelve/vendor/UPSTREAM-VENDOR-SOURCES.json new file mode 100644 index 0000000000..cd19eda259 --- /dev/null +++ b/research/t74-joint-twelve/vendor/UPSTREAM-VENDOR-SOURCES.json @@ -0,0 +1,26 @@ +{ + "vendor/gf_chart.py": { + "sha256": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/census.py", + "mode": "four unchanged gf_* functions" + }, + "vendor/target_transport.py": { + "sha256": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/target_transport.py", + "mode": "unchanged full file" + }, + "vendor/generate_words.py": { + "sha256": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/generate_words.py", + "mode": "unchanged full file" + }, + "vendor/GENERATOR-NOTICE.txt": { + "sha256": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/GENERATOR-NOTICE.txt", + "mode": "unchanged full file" + } +} diff --git a/research/t74-joint-twelve/vendor/ceiling.py b/research/t74-joint-twelve/vendor/ceiling.py new file mode 100644 index 0000000000..6c0f54527d --- /dev/null +++ b/research/t74-joint-twelve/vendor/ceiling.py @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Packing-independent ceiling for a complex local word under the hosted nine-stage coverage law. + +Model (all inputs explicit): + * per replica the template has `families` live data families and `stages` invocations, so + w = families / stages live families per call; on the selected T37/T16 line all helpers are + hosted on data families, so w = 2 * pairs * V / stages is fixed by the port count V; + * coverage identity (PR1012, re-checked here on the selected profile): paid rank mass equals + (m - 1) * W + centre * N, i.e. every live family keeps exactly one unpaid coordinate and every + call pays its centre path (`unpaid` > 1 is a what-if for a changed coverage law only); + * the local word fixes its own paid child profile `local` (per call); + * every remaining unit of mass is an idle/remainder child of rank at most R, where the outer + recipe's halving guard m^2 > 2 R^2 bounds R (R = 51 for m = 73). + +Lemma. For a >= 0, a child of rank r costs (r/m)^(1-a) = r * c(r), with c(r) = r^(-a) m^(a-1) +non-increasing in r. Hence, with idle mass M fixed and idle ranks <= R, every idle histogram has +moment >= the relaxation that puts all of M into (possibly fractional) rank-R children: + + relax(a) = [ sum_local n_r (r/m)^(1-a) + (M/R) (R/m)^(1-a) ] / w (per call). + +The moment is increasing in a. So relax(a*) > 1 certifies that no hosting, owner packing or +idle-remainder change of the given local word, template and outer recipe certifies a saving +>= a*. Under the retained reduction kappa < a/(1+a) when the complex side binds, so +a*/(1+a*) also bounds kappa. This is a bound for the stated model, not for other local words, +templates, coverage laws or outer recipes. + +Exact rational intervals: ln k from atanh chains, exp by Taylor with Lagrange remainder, +outward rounding to 2^-PREC. Standard library only. Douglas Colkitt, with Claude (Anthropic) +assistance. +""" +from fractions import Fraction as Q +from functools import lru_cache +from math import isqrt + +PREC = 256 + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def down(x): + return Q((x.numerator << PREC) // x.denominator, 1 << PREC) + + +def up(x): + return -down(-x) + + +@lru_cache(None) +def atanh(t): + """Enclosure of atanh(t) for rational 0 < t <= 1/3.""" + require(0 < t <= Q(1, 3), 'atanh range') + s, p, k = Q(0), t, 0 + while True: + term = p / (2 * k + 1) + s += term + p *= t * t + k += 1 + tail = p / ((2 * k + 1) * (1 - t * t)) + if tail < Q(1, 1 << (PREC + 8)): + return down(s), up(s + tail) + + +@lru_cache(None) +def ln(k): + """Enclosure of ln k for an integer k >= 1: ln k = ln(k-1) + 2 atanh(1/(2k-1)).""" + require(isinstance(k, int) and k >= 1, 'ln domain') + if k == 1: + return Q(0), Q(0) + lo, hi = ln(k - 1) + a, b = atanh(Q(1, 2 * k - 1)) + return down(lo + 2 * a), up(hi + 2 * b) + + +def exp(lo, hi): + """Enclosure of exp([lo, hi]) for 0 <= lo <= hi <= 1/2.""" + require(0 <= lo <= hi <= Q(1, 2), 'exp range') + def series(y, upper): + s, t, k = Q(1), Q(1), 0 + while True: + k += 1 + t = t * y / k + s += t + if t * y < Q(1, 1 << (PREC + 8)): + return up(s + 2 * t * y / (k + 1)) if upper else down(s) + return series(lo, False), series(hi, True) + + +def child_cost(r, m, a): + """Enclosure of (r/m)^(1-a) = (r/m) exp(a ln(m/r)).""" + lm, um = ln(m) + lr, ur = ln(r) + e = exp(max(Q(0), a * (lm - ur)), a * (um - lr)) + return down(Q(r, m) * e[0]), up(Q(r, m) * e[1]) + + +def max_idle_rank(m): + """Largest R with m^2 > 2 R^2 (outer halving guard).""" + R = isqrt((m * m - 1) // 2) + while 2 * (R + 1) ** 2 < m * m: + R += 1 + while 2 * R * R >= m * m: + R -= 1 + return R + + +def model(local, m, families, stages, centre, R=None, unpaid=1): + """Per-call quantities. local: {rank: count per call (Fraction ok)}.""" + R = max_idle_rank(m) if R is None else R + require(2 * R * R < m * m, 'idle rank cap violates the halving guard') + require(all(0 < r < m for r in local) and all(n >= 0 for n in local.values()), 'local profile') + w = Q(families, stages) + require(1 <= unpaid < m, 'unpaid coordinates per family') + total = (m - unpaid) * w + centre + local_mass = sum(r * Q(n) for r, n in local.items()) + idle = total - local_mass + require(idle >= 0, 'local word pays more mass than the coverage law allows') + return dict(R=R, w=w, total_mass=total, local_mass=local_mass, idle_mass=idle, deficit=unpaid * w - centre) + + +def relax(local, m, families, stages, centre, a, R=None, unpaid=1): + """Enclosure of the per-call relaxation moment at saving a.""" + q = model(local, m, families, stages, centre, R, unpaid) + lo = hi = Q(0) + for r, n in local.items(): + c = child_cost(r, m, a) + lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1] + c = child_cost(q['R'], m, a) + k = q['idle_mass'] / q['R'] + lo, hi = lo + k * c[0], hi + k * c[1] + return down(lo / q['w']), up(hi / q['w']) + + +def ceiling(local, m, families, stages, centre, grid=Q(1, 10 ** 15), R=None, unpaid=1): + """Grid bracket [a_lo, a_hi]: relax(a_lo) < 1 < relax(a_hi), certified. a_hi is the ceiling.""" + lo, hi = Q(0), Q(1, 20) + require(relax(local, m, families, stages, centre, hi, R, unpaid)[0] > 1, 'search window too small') + require(relax(local, m, families, stages, centre, lo, R, unpaid)[1] < 1, 'relaxation has no positive saving') + while hi - lo > grid: + mid = Q(int((lo + hi) / 2 / grid)) * grid + if mid <= lo: + mid = lo + grid + v = relax(local, m, families, stages, centre, mid, R, unpaid) + if v[1] < 1: + lo = mid + elif v[0] > 1: + hi = mid + else: + raise ValueError('enclosure too wide to separate the grid point') + return lo, hi diff --git a/research/t74-joint-twelve/vendor/generate_words.py b/research/t74-joint-twelve/vendor/generate_words.py new file mode 100644 index 0000000000..94bf0d8f29 --- /dev/null +++ b/research/t74-joint-twelve/vendor/generate_words.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Construct four coherent handoffs on the pinned PR2312 width-exchange words. + +This is a direct circuit transformation, using Python's standard library only. +It moves the twelve block-616 correction gates, replaces four retired helper +roles by the source lenders (1,4,6,12), installs their explicit invertible chart +maps, and derives inverse-reverse cleanup from the changed non-target word. +The source and resulting word content are hash-bound. Hash equality is a +reproduction check; the independent all-column native chain proves correctness. +The input retains PR2312's width exchange (alias 651 re-lent from 530 and +alias 653 dropped), exact frame re-solve and the pivot-518/506 kernels. +Width exchange and its source frame/owner work are credited to Jeremy Kothe +(jeremykothe2), with AI assistance. The helper-donor kernels retain credit: +PR1625 shape by mdumitrean; PR2302 search, exact pricing and frame re-solve +by Jeremy Kothe (jeremykothe2), with AI assistance. This derivative was also +prepared with substantial AI assistance. See GENERATOR-NOTICE.txt for +inherited attribution and licensing. +""" +import argparse +import copy +import gzip +import hashlib +import json +import platform +import zlib +from collections import Counter, defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PACKAGE = Path('research/gmx-t74-borrow43-width-exchange') +SOURCE_COMMIT = 'fb76f799ccf078f51780076ebed3fd26b1db11c0' +SOURCE_MANIFEST = 'c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313' +SOURCE_WORDS = { + 'base': '4244149b59b287344b0e91aa50c6fa2a2491ee6c7a76d61cd352684a8182d005', + 'extra': '01d510cc4ba912567f6b02ea50b6b0e741ed231a3608de9c36e7eeccbdaf6cda', +} +TARGET_WORDS = { + 'base': '93c32c9dc8ca18394b7f3afac2cb4fa8582a6cb77399441b5107b396e63ca0f9', + 'extra': 'aae6592eaa4cf8638f21d50c44d09d4f8a6bb079ddcf5e377711a10ee2ddb526', +} +TARGET_SEMANTICS = { + 'base': '3659c066d5cc2413a6f59bae8d5886e05feb8148333516f65365ad5235e14f2a', + 'extra': '9369702d158c34d594481a1789a2bddc029d03007253620cf3834ec60a88b1a5', +} +HIGH = (619, 621, 622, 623) +LOW = (616, 617, 618, 620) +LENDERS = (1, 4, 6, 12) +COMMON5 = (260, 132, 75, 42, 25) +COMMON4 = (260, 132, 75, 51) +# Literal G(e_i) columns of the four new rank-zero K_G handoffs. Each map is +# independently checked below, then physically lowered by the native auditor. +G_COLUMNS = ( + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 16, 32, 64, 135, 263), + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 57, 66, 143, 16, 272), +) +PROFILE = {1: 2335, 2: 512, 3: 426, 4: 120, 5: 38, 8: 8} +WIDTHS = {4: 33, 5: 9, 7: 38, 8: 114, 9: 240} + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def semantic_sha(value): + # JSON object keys are strings; normalize integer invoice keys before sorting. + value = json.loads(json.dumps(value)) + return sha(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()) + + +def basis(vectors): + """Canonical reduced GF(2) row basis, independent of set iteration order.""" + piv = {} + for value in vectors: + while value: + bit = value.bit_length() - 1 + if bit in piv: + value ^= piv[bit] + else: + piv[bit] = value + break + for bit in sorted(piv): + for higher in piv: + if higher > bit and (piv[higher] >> bit) & 1: + piv[higher] ^= piv[bit] + return tuple(piv[bit] for bit in sorted(piv, reverse=True)) + + +def incident(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def mapped(columns, vector): + result = 0 + for bit, column in enumerate(columns): + if (vector >> bit) & 1: + result ^= column + return result + + +def derive_cleanup(word): + """PR2226/PR2288 inverse-reverse cleanup, retaining proper-end buffers.""" + v = word['report']['v'] + n = 2 * v + word['report']['R'] + restored = set(map(int, word['helper_final'])) + full = list(basis(1 << bit for bit in range(word['report']['h']))) + buffer = lambda role: role + n if role in restored else role + by_position = defaultdict(list) + for operator, record in enumerate(word['warps'], 1): + by_position[record[0]].append((record[1], operator)) + forward = list(word['A']) + for position in range(len(word['B']) + 1): + forward.extend(['warp', role, operator] + for role, operator in by_position[position]) + if position < len(word['B']): + forward.append(word['B'][position]) + forward += word['restore'] + cleanup = [] + for gate in reversed(forward): + if gate[0] == 'warp': + cleanup.append(['warp', buffer(gate[1]), -gate[2], full]) + elif not v <= gate[1] < 2 * v: + if gate[0] == 'add': + cleanup.append(['add', buffer(gate[1]), buffer(gate[2]), + -gate[3], gate[4], full]) + else: + cleanup.append(['scale', buffer(gate[1]), gate[3], gate[2], full]) + return cleanup + + +def paid_profile(word): + """Recount literal native climbs, cut copies and retained helper widths.""" + v, h, helpers = (word['report'][key] for key in ('v', 'h', 'R')) + n = 2 * v + helpers + cur = [(port,) for port in word['ports']] + [()] * (v + helpers) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + full = basis(1 << bit for bit in range(h)) + ends = [full] * v + [basis(x for x in range(1, 1 << h) + if (x & port).bit_count() % 2 == 0) + for port in word['ports']] + [full] * helpers + for role, frame in word['helper_final'].items(): + ends[int(role)] = basis(frame) + paid = Counter() + + def climb(role, frame): + frame = basis(frame) + require(basis(cur[role] + frame) == frame, 'Nonmonotone frame chain') + degree = len(frame) - len(cur[role]) + if degree: + paid[degree] += 1 + cur[role] = frame + + def gate(event): + for role in incident(event): + climb(role, event[-1]) + + for event in word['A']: + gate(event) + levels = {int(t): basis(frame) for t, frame in word['target_levels'].items()} + require(all(cur[v+t] == levels.get(t, ()) for t in range(v)), 'Cut target frame') + for role, frame in zip(word['centers'], word['center_frames']): + frame = basis(frame) + require(cur[role] == frame, 'Cut producer frame') + readers = {levels.get(event[1]-v, ()) for event in word['cut'] + if event[2] == role} + for reader in sorted(readers, key=lambda x: -len(x)): + require(basis(reader + frame) == frame, 'Unnested private copy') + if reader != frame: + paid[len(frame)-len(reader)] += 1 + frame = reader + by_position = defaultdict(list) + for record in word['warps']: + by_position[record[0]].append(record) + for position in range(len(word['B']) + 1): + for _, role, columns, old, new in by_position[position]: + require(cur[role] == basis(old), 'Handoff source frame') + require(len(basis(columns)) == h, 'Singular chart map') + require(basis(mapped(columns, x) for x in old) == basis(new), + 'Chart map does not carry the measured source frame') + cur[role] = basis(new) + if position < len(word['B']): + gate(word['B'][position]) + for event in word['restore']: + gate(event) + live = set(range(n)) - set(word['removed']) + for role in live: + climb(role, ends[role]) + widths = Counter(len(ends[role]) - len(basis(word['start_extra'].get(str(role), []))) + for role in live if role >= 2 * v) + return dict(sorted(paid.items())), dict(sorted(widths.items())) + + +def build(source): + word = copy.deepcopy(source) + require(word['report']['v'] == 112 and word['report']['h'] == 9 + and word['report']['R'] == 480, 'Unexpected source geometry') + roles = set(LOW + HIGH) + prep = [i for i, event in enumerate(word['B']) + if set(incident(event)) <= roles] + # The only internal gates before source acquisition are the twelve M gates. + first = next(i for i, event in enumerate(word['B']) + if event[0] == 'add' and event[1] in roles + and event[2] not in roles and len(event[-1]) >= 6) + prep = [i for i in prep if i < first] + require(len(prep) == 12 and prep == list(range(prep[0], prep[0]+12)), + 'Expected twelve consecutive block-616 correction gates') + lo, hi = prep[0], prep[-1] + 1 + require(all(not roles.intersection(incident(event)) + for event in word['B'][hi:first]), 'Block is not idle before relocation') + require(all(basis(word['B'][i][-1]) == basis(COMMON5) for i in prep), + 'Unexpected correction chart') + require(all(event[0] == 'add' and event[1] in LOW and event[2] in HIGH + for event in (word['B'][i] for i in prep)), 'Unexpected correction payload') + require(all(basis(word['start_extra'][str(role)]) == basis(COMMON5) + for role in HIGH), 'Unexpected removed helper entrance') + require(not any(record[0] in range(lo, hi+1) or record[0] == first + for record in word['warps']), 'Warp inside relocation boundary') + replace = dict(zip(HIGH, LENDERS)) + moved = [event[:-1] + [list(COMMON4)] for event in word['B'][lo:hi]] + word['B'] = word['B'][:lo] + word['B'][hi:first] + moved + word['B'][first:] + handoff = first - len(moved) + for event in word['B']: + for index in range(1, 3 if event[0] == 'add' else 2): + event[index] = replace.get(event[index], event[index]) + for record in word['warps']: + if hi <= record[0] < first: + record[0] -= len(moved) + # Preserve the already-audited literal basis representatives emitted by + # the original builder. These replacements span precisely the same U. + rewrite = {(384, 134, 120, 30): (384, 134, 102, 30), + (448, 56, 21, 11): (448, 38, 21, 11)} + old = tuple(record[3]) + if old in rewrite: + require(basis(old) == basis(rewrite[old]), 'Basis serialization changed U') + record[3] = list(rewrite[old]) + # Measure each retired source at the chronological handoff, without trusting + # a lender chart copied from a generated target artifact. + cur = [(port,) for port in word['ports']] + [()] * (112 + 480) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + for event in source['A']: + for role in incident(event): + cur[role] = basis(event[-1]) + old_warps = defaultdict(list) + for record in source['warps']: + old_warps[record[0]].append(record) + for position in range(first): + for record in old_warps[position]: + cur[record[1]] = basis(record[4]) + for role in incident(source['B'][position]): + cur[role] = basis(source['B'][position][-1]) + for role, columns in zip(LENDERS, G_COLUMNS): + require(len(cur[role]) == 4, 'Retired lender must be rank 4') + require(max(i for i, event in enumerate(source['B']) + if role in incident(event)) < first, 'Source lender still live') + old_literal = (384, 131, 75, 51) if role == 4 else cur[role] + new_literal = (384, 132, 75, 51) + require(basis(old_literal) == cur[role] + and basis(new_literal) == basis(COMMON4), + 'Literal handoff representative changed its subspace') + word['warps'].append([handoff, role, list(columns), + list(old_literal), list(new_literal)]) + for role in HIGH: + del word['start_extra'][str(role)] + word['removed'] = sorted(set(word['removed']).union(HIGH)) + word['base'] = 'PR2312-width-exchange-plus-coherent-joint616' + profile, widths = paid_profile(word) + require(profile == PROFILE and widths == WIDTHS, 'Unexpected generated invoice') + word['report']['local_profile'] = profile + word['report']['width_inventory'] = widths + word['cleanup'] = derive_cleanup(word) + return word, dict(old_correction_interval=[lo, hi], old_first_input=first, + relocated_correction_interval=[handoff, handoff+12], + removed_roles=list(HIGH), lenders=list(LENDERS)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, required=True, + help='Repository root containing the pinned PR2312 package') + parser.add_argument('--out', '--output', type=Path, required=True, + help='Destination for base.json.gz, extra.json.gz and GENERATION.json') + args = parser.parse_args() + package = args.source_root.resolve() / PACKAGE + manifest_bytes = (package / 'MANIFEST.json').read_bytes() + require(sha(manifest_bytes) == SOURCE_MANIFEST, 'Unpinned upstream manifest') + manifest = json.loads(manifest_bytes) + args.out.mkdir(parents=True, exist_ok=True) + reports = {} + for kind in ('base', 'extra'): + relative = f'new/borrow/words/BORROW-WORD-43{kind}.json.gz' + raw = (package / relative).read_bytes() + require(sha(raw) == SOURCE_WORDS[kind] == manifest[relative], + 'Unpinned '+kind+' source word') + word, changes = build(json.loads(gzip.decompress(raw))) + content = json.dumps(word, separators=(',', ':')).encode() + canonical_hash = semantic_sha(word) + require(canonical_hash == TARGET_SEMANTICS[kind], + 'Generated '+kind+' circuit differs from the frozen audited input') + compressed = bytearray(gzip.compress(content, compresslevel=9, mtime=0)) + compressed[9] = 255 # Normalize the Python 3.11/3.12 gzip OS header byte. + compressed = bytes(compressed) + destination = args.out / (kind+'.json.gz') + destination.write_bytes(compressed) + reports[kind] = dict(source_word_sha256=sha(raw), output=destination.name, + output_sha256=sha(compressed), content_sha256=sha(content), + canonical_json_sha256=canonical_hash, + frozen_container_sha256=TARGET_WORDS[kind], + container_matches_frozen=sha(compressed) == TARGET_WORDS[kind], + local_profile=word['report']['local_profile'], + width_inventory=word['report']['width_inventory'], + changes=changes) + print('PASS_GENERATED_AUDITED_WORD_SEMANTICS', kind, canonical_hash, flush=True) + receipt = dict(status='PASS_SOURCE_BOUND_EXACT_WORD_GENERATION', + source_commit=SOURCE_COMMIT, source_manifest_sha256=SOURCE_MANIFEST, + generator_sha256=sha(Path(__file__).read_bytes()), words=reports, + compression_environment=dict(python=platform.python_version(), + zlib=zlib.ZLIB_RUNTIME_VERSION), + equality='Canonical JSON of every field; gzip container hashes are metadata', + scope='Exact source-bound reproduction of the independently audited words. ' + 'Circuit correctness, physical phases and the global owner invoice ' + 'are established by their separate native and global receipts.') + (args.out / 'GENERATION.json').write_text(json.dumps(receipt, indent=2)+'\n') + + +if __name__ == '__main__': + main() diff --git a/research/t74-joint-twelve/vendor/gf_chart.py b/research/t74-joint-twelve/vendor/gf_chart.py new file mode 100644 index 0000000000..11f5bfd882 --- /dev/null +++ b/research/t74-joint-twelve/vendor/gf_chart.py @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +# Exact GF(2) chart utilities extracted from PR2436 census.py; unchanged functions. + +def gf_rank(xs): + b = {} + for x in xs: + while x: + j = x.bit_length() + if j not in b: + b[j] = x + break + x ^= b[j] + return len(b) + +def gf_extend(xs, h): + out = list(xs) + for j in range(h): + if gf_rank(out + [1 << j]) > len(out): + out.append(1 << j) + assert len(out) == h + return out + +def gf_linear(cols, x): + out = 0 + for j, c in enumerate(cols): + if x >> j & 1: + out ^= c + return out + +def gf_change(source, target, h): + a, b = gf_extend(source, h), gf_extend(target, h) + back = {gf_linear(a, x): x for x in range(1 << h)} + assert len(back) == 1 << h + return [gf_linear(b, back[1 << j]) for j in range(h)] diff --git a/research/t74-joint-twelve/vendor/target_transport.py b/research/t74-joint-twelve/vendor/target_transport.py new file mode 100644 index 0000000000..89ee0168c6 --- /dev/null +++ b/research/t74-joint-twelve/vendor/target_transport.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Exact target-vector transport; no physical/native admission is implied. + +For a final correction c, compute the unique simultaneous correction at every +boundary of a target-affine gate word. Non-target source terms cancel from the +difference. Transport through target mixing, not only target scales. +""" +from fractions import Fraction as Q + + +def need(ok, msg): + if not ok: + raise RuntimeError(msg) + + +def step(c, gate, targets, inverse=False): + out=dict(c) + kind=gate[0] + if kind not in ('add','scale'): + return out + t=gate[1] + if kind=='add': + s=gate[2] + need(not (s in targets and t not in targets), 'non-target reads target') + if t in targets and s in targets: + a=Q(gate[3],gate[4])*(-1 if inverse else 1) + out[t]=out.get(t,Q(0))+a*out.get(s,Q(0)) + elif t in targets: + a=Q(gate[2],gate[3]);need(a!=0,'zero target scale') + out[t]=out.get(t,Q(0))*(1/a if inverse else a) + return {t:a for t,a in out.items() if a} + + +def suffix_corrections(gates, final, targets): + need(set(final)<=set(targets),'correction outside targets') + c={t:Q(a) for t,a in final.items() if a} + vectors=[c] + for g in reversed(gates): + c=step(c,g,targets,inverse=True) + vectors.append(c) + return list(reversed(vectors)) + + +def verify_transport(gates, final, targets): + vectors=suffix_corrections(gates,final,targets) + need(len(vectors)==len(gates)+1,'missing boundary') + for i,g in enumerate(gates): + need(step(vectors[i],g,targets)==vectors[i+1],f'transport boundary {i}') + need(vectors[-1]=={t:Q(a) for t,a in final.items() if a},'wrong final') + return vectors + + +def controls(): + # A correction on source target 11 is mixed into target 10 by an ADD; + # a scalar-only backward transport would miss this exact obstruction. + targets={10,11};gates=[['add',10,11,3,2,[]],['scale',11,-2,1,[]]] + final={10:Q(5),11:Q(4)} + v=verify_transport(gates,final,targets) + need(v[0]=={10:Q(8),11:Q(-2)},'known noncommuting two-target example') + wrong=dict(v[0]);wrong[10]=Q(5) + for g in gates:wrong=step(wrong,g,targets) + need(wrong!=final,'ignored-mixing control accepted') + try:step({10:Q(1)},['add',0,10,1,1,[]],targets) + except RuntimeError:pass + else:raise RuntimeError('target read into non-target not rejected') + return {'noncommuting_target_mix':'rejected_scalar_only_transport','non_target_read':'rejected'} + + +if __name__=='__main__': + need(__debug__,'assertions must remain enabled') + controls() + print('PASS_EXACT_TARGET_TRANSPORT_CONTROLS') diff --git a/research/t74-joint-twelve/verify.py b/research/t74-joint-twelve/verify.py new file mode 100644 index 0000000000..bae5b71ecc --- /dev/null +++ b/research/t74-joint-twelve/verify.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Read-only finite replay: words, corrections, cleanup, hosting and exact moment. +No assertion-optimized execution; full native/outer release is separate. +""" +import copy,gzip,hashlib,json +from pathlib import Path +from fractions import Fraction as F +import sys +sys.path.insert(0,str(Path(__file__).resolve().parent)) +import composition as C +import independent_local as L +import independent_owners as I +import exact_moment as M +HERE=Path(__file__).resolve().parent +PROFILE={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +LOW=F('0.001717141586348426338109') +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(name): + p=HERE/'inputs'/name;b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def run(): + need(__debug__,'run without -O: inherited independent local checker uses assertions') + pins=json.loads((HERE/'INPUT-PINS.json').read_text()) + for path,digest in pins.items():need(hashlib.sha256((HERE/path).read_bytes()).hexdigest()==digest,'input digest '+path) + claim=json.loads((HERE/'CLAIM.json').read_text()) + need({int(k):v for k,v in claim['profile'].items()}==PROFILE,'claim profile') + need(F(claim['complex_lower'])==LOW and F(claim['complex_upper'])==LOW+F(1,10**24),'claim bracket') + need(F(claim['kappa'])==LOW-F(1,10**46)-F(1,10**70),'claim outer endpoint') + for name in ('PR2733','PR2745'): + previous=json.loads((HERE/'evidence'/f'{name}-CLAIM.json').read_text()) + need(F(claim['kappa'])>F(previous['kappa']),'strict improvement over '+name) + words={} + for tag,pid in [('base','gauge44'),('extra','extra')]: + w=rd('WORD-'+tag+'.json.gz');words[pid]=w + L.check_frames(w);L.check_cleanup(w);L.algebra(w) + need(set(int(t)+112 for t in w['target_levels']).isdisjoint(g[1] for g in w['cut']),'lifted targets avoid every cut read') + for label in ['drop_anticipatory','reverse_anticipatory','reverse_recovery']: + bad=copy.deepcopy(w) + if label=='drop_anticipatory':bad['initial_corrections'].pop() + elif label=='reverse_anticipatory':bad['initial_corrections'][0]['coefficient']=str(-F(bad['initial_corrections'][0]['coefficient'])) + else: + j=next(i for i,g in enumerate(bad['B']) if g[:5]==['add',49,33,-1,1]);bad['B'][j][3]=1 + try:L.algebra(bad) + except AssertionError:pass + else:raise ValueError('accepted mutation '+label) + order,fill,providers=rd('ORDER.json'),rd('FILL.json.gz'),rd('PROVIDERS.json') + dispatch={(s,r):p for s,r,p in rd('DISPATCH.json.gz')} + need(order==rd('SOURCE-ORDER.json'),'source order') + constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),providers,rd('SOURCE-FILL.json.gz'),order,dispatch,words) + need(constructed==fill,'complete deterministic fill') + owner=I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,fill,providers,dispatch,PROFILE) + bad=copy.deepcopy(fill);bad['rows'][0][5]=999 + try:I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,bad,providers,dispatch,PROFILE) + except (ValueError,RuntimeError):pass + else:raise ValueError('accepted out-of-bin placement') + _,a=M.moment_bounds(PROFILE,LOW);b,_=M.moment_bounds(PROFILE,LOW+F(1,10**24));need(a<6630466304,'PR2733 rejects candidate endpoint') + return {'status':'PASS_JOINT_TWELVE_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} +if __name__=='__main__':print(json.dumps(run(),indent=2)) diff --git a/research/t74-joint-twelve/workflow/admit.py b/research/t74-joint-twelve/workflow/admit.py new file mode 100644 index 0000000000..4606a5024e --- /dev/null +++ b/research/t74-joint-twelve/workflow/admit.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a composed-word COMPOSED order/fill derivative. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-pr2733' +SOURCE_MANIFEST = '7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'native-cache', 'native-receipt', 'work'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + a = ap.parse_args() + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == 491 and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + write(work / 'RUNTIME-PATCHES.json', patches) + shutil.copy2(a.fill, package / 'new/borrow-fill/FILL.json.gz') + shutil.copy2(a.order, package / 'new/borrow-fill/ORDER.json') + run('owners', package / 'reconstruct.py', '--out', work / 'owners') + run('parent-lift', package / 'lift_parent.py', '--owners', work / 'owners', '--out', work / 'parent-data') + for name in ('PLAN.json', 'OWNERS.json.gz', 'DISPATCH.json', 'PROFILE.json', 'CONSTRUCTION.json', + 'GLOBAL-TEMPLATE.json.gz', 'SPEC.json'): + shutil.copy2(work / 'parent-data' / name, package / name) + shutil.copy2(work / 'owners/ORDER.json', package / 'ORDER.json') + spec = read(package / 'SPEC.json') + spec['outer_refinement'] = PRECISION + spec['expected']['live'] = 66304 + # COMPOSED's pre-life mechanism changes which helper labels retain width8. + # Preserve its declared spot set; rebind and the original strict verifier + # still check the actual native widths, including every other helper. + source_spots = read(source / 'new/SPEC.json')['width_spot_helpers'] + need(source_spots == [278, 281, 284, 289], 'COMPOSED source spot-width pins') + spec['width_spot_helpers'] = source_spots + write(package / 'new/SPEC.json', spec) + run('rebind', package / 'new/rebind.py', package, natives['base'] / 'local', + natives['extra'] / 'local', work / 'rebound') + spec = read(work / 'rebound/SPEC.json') + need(spec['expected']['physical'] == 66801, 'complete physical cost including 72 buffers') + layout = work / 'layout' + layout.mkdir() + with tarfile.open(old / 'upstream-layout.tar.gz') as archive: + need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + for m in archive.getmembers()), 'retained archive paths') + archive.extractall(layout, filter='data') + runtime = layout / 'packing74' + runtime.mkdir() + for name in ('replay.py', 'freeze_spec.py', 'audit_mixed.py', 'independent_core.py', 'geometry_controls.py', 'audit_fast.py'): + shutil.copy2(package / name, runtime / name) + for name in ('code', 'construction', 'inputs'): + shutil.copytree(package / name, runtime / name) + shutil.copytree(work / 'rebound', runtime / 'candidate') + shutil.copytree(natives['extra'], runtime / 'native-extra') + data = runtime / 'candidate' + result = dict(status='PREPARED_COMPOSED_SAME_WORD_DERIVATIVE_NOT_ADMITTED', source_commit=SOURCE_COMMIT, + source_manifest_sha256=SOURCE_MANIFEST, native_receipt_sha256=sha(a.native_receipt), + fill_sha256=sha(package / 'new/borrow-fill/FILL.json.gz'), + order_sha256=sha(package / 'new/borrow-fill/ORDER.json'), profile=read(work / 'rebound/PROFILE.json'), + patches=patches, scope='Prepared only; source/native/parent inputs authenticated and literal owner fill reconstructed.') + write(work / 'RESULT.json', result) + if a.prepare_only: + print(result['status'], flush=True) + return + run('discovery', runtime / 'replay.py', '--data', data, '--work', work / 'discovery', + '--local', natives['base'] / 'local', '--discover') + supplier = read(work / 'discovery/RESULT.json') + for name in ('PLAN.json', 'PROFILE.json', 'SPEC.json'): + shutil.copy2(data / name, package / 'new' / name) + spec = read(package / 'new/SPEC.json') + original_claim = read(source / 'CLAIM.json') + claim = dict(status='CONDITIONAL_CANDIDATE_EXPECTED_BY_REPLAY', kappa=supplier['kappa'], + kappa_decimal=supplier['kappa_decimal'], baseline_pr=2679, baseline_head=SOURCE_COMMIT, + baseline_kappa=read(source / 'outer/OUTER-CLAIM.json')['kappa'], outer_refinement=PRECISION, + scope=original_claim['scope'], kappa_layers=original_claim['kappa_layers'], + headline_kappa_source='outer/OUTER-CLAIM.json', + verification='Candidate discovered from literal fill; full original verification must pass separately.') + write(package / 'CLAIM.json', claim) + C = Q(spec['expected']['complex_lower']) + write(package / 'outer/B.json', dict(b=str(C-Q(1,10**104)), b_above_endpoint=str(C+Q(1,10**24)), + profile=spec['expected']['global_profile'], live=spec['expected']['live'])) + for name in ('check_ledger.py', 'independent_check.py'): + run('outer-' + name, package / 'outer' / name) + ledger = read(package / 'outer/LEDGER.json') + row = ledger['rows']['struct_boundary_radix_union']['kappa'] + kappa = Q(row['rational']) + previous = Q('0.0017161404259974415161889999999999999999999998999999999999999999999999') + need(kappa == C-Q(1,10**70)-Q(1,10**46) and kappa > previous, + 'candidate must strictly improve pinned COMPOSED before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=SOURCE_COMMIT, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + result.update(status='PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main()