Clean private Pasterski release presentation and add replay validation

CITATION.cff

@@ -1,5 +1,5 @@
 cff-version: 1.2.0
-message: "If you use this work, please cite the Ouroboros AI System."
+message: "Machine-readable metadata for this Ouroboros AI System research release."
 title: "Advancing the Pasterski Research Program: A Paused, Proof-Carrying Computational Campaign"
 type: software
 authors:

NOTICE

@@ -1,8 +1,4 @@
 Ouroboros Pasterski Research Program
 Copyright 2026 Ouroboros AI System
 
-Required attribution: "Ouroboros AI System".
-
-All substantive research discovery, derivation, testing, and manuscript production in this package were performed by the Ouroboros AI System. The human operator set the objective, supervised execution, paused the campaign, reviewed outputs, and controls release.
-
-The cited papers remain the work of Sabrina Pasterski and their respective coauthors. Their inclusion does not imply endorsement. Preserve this NOTICE in redistributed or adapted copies.
+This product includes replay code and generated research materials produced by the Ouroboros AI System. Preserve this NOTICE with redistributed copies containing the Apache-licensed replay code. Full attribution, licensing, access, and no-endorsement terms are in `ATTRIBUTION_AND_USE.md`.

PAPER.md

@@ -135,7 +135,7 @@ This paper does not claim access to the Ouroboros implementation. Public replay
 
 ## 11. Use and credit
 
-The new work is free to use under the licenses in this package, provided **Ouroboros AI System** is credited and the NOTICE is preserved. Original papers and coauthors must be cited independently. No endorsement by Sabrina Pasterski or any coauthor is implied.
+See `ATTRIBUTION_AND_USE.md` for licensing, attribution, access terms, and the no-endorsement boundary.
 
 ## 12. Conclusion
 

review/Ouroboros_Pasterski_Research_Program_PAUSED.pdf → PAPER.pdf

@@ -202,7 +202,7 @@ endobj
 endobj
 23 0 obj
 <<
-/Author (Ouroboros AI System) /CreationDate (D:20260812180601-04'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260812180601-04'00') /Producer (ReportLab PDF Library - www.reportlab.com) 
+/Author (Ouroboros AI System) /CreationDate (D:20260812191633-04'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260812191633-04'00') /Producer (ReportLab PDF Library - www.reportlab.com) 
   /Subject (PAUSED research / private review stage) /Title (Advancing the Pasterski Research Program) /Trapped /False
 >>
 endobj
@@ -312,10 +312,10 @@ Gat=,?#SIW(4FN4\8RjB,T9=aPBcrRh<A;P=J24Uls_%0Kr2"(:*`[[.D,TRHS-bhDEEl0U-OjnjS_48
 endobj
 39 0 obj
 <<
-/Filter [ /ASCII85Decode /FlateDecode ] /Length 1797
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1711
 >>
 stream
-Gat=+9on$e&A@P9Qt'=PMC$rfG&g4(/J+RG[TM_D$SBa=@u=5Vb)ZILhb`ma-?T_"$Y21Q3M5cR)5f=/:E'6b)PTIIo_PbUdYua]9'=<depl0/qX3ZT3o4+Pacc'6<_8#N31n02=5DhLHEsuHdCL2hc(_1r%D>rsOp]UD6</b$01upplg-R\L`gh9q/f2fdTTd@N@h!(@!C&oKKcqE\uFL\)c7If\l+^`+hi:jo+a:MV/SjtXXJ@eP5[CDJ"cQ(oL]7,[]=/1T?h]01nX/AfVV]\j/WKo](8m'fA]lfQVI\%_T0M1AZ?((V,LSuN9@o6TpB$\#mjP%I(%j#O*@Hb^bAp(X/.3XqIjT\.@P!T3Is:\<B42*OWbilmn>u?#N:d\@OWUpETrK$PO_[&?YCBOG`aL:@GkuI$\@kHb@NC/^8Nj%CKp*+?Jr=iSr8!#SM"oQ[.KrSfieUcC6)J3@0j-Ya2jA].=C;h"+)DF)h_B%f-g26OSi-moYnl*lp@$9p19#ce[2cUj2="AiFqMQhG.('9D`CmMS@Fm3ViaNrkZnk!6bZJrqOV6in>dUiocu*&"(TAr.s$;`,%J-ke1X5R\iE4)PK+20#[27LbcRXj^RcL9*G+@3P2QAHA2Ede1%(gel$@odW+rgc8Hrh)H=/RW+IWu#/@:X.JHc\<WePqHuS9ZTVbD!>,fl!Ll283aYTN(fH)1!n9cnYZi^[r#Qrh5l.9,!AHW'0"g\QC#k.n]T]:`r7^S\RH4g9E%<2GeUA3Fk#=b4'%nrK)it=h6D6:6H:NfC>"]p5CNKt#k'M^D>7.ft;(4jY-91EtG1n--uM&WrcOr_<NB7qJ':'X!De!FQdHd9(k!Y4^I"FuX;e\P/G<@:Y"TQD_,,(a-'<YLQ*/IEmrK>T9rF,hBWh[62G77^@e&1^t8(),DDJM$R@:^q!i/q?q[3mlNe?oe4."%Ron7N&!-97676Eu']+$7=r:)jnj9=%"&<D[#1"ZuSE"TnPhNMLr)k7XfpEVU^gpO[BF<7Cbgo+gX=RUpYZ9OX!uRJ.T<UFF8j5YcC',e=O;@HQ]I_k]&7t(G@L@/fY*sRg@A(l5s5G%JV.lA;)K6ede,7'pSA"#\BllB:+m[!d(/3*E8uPlh_g6Db1H<Xc!N==\k%U/o<l)[XA9raVl`f&q[jO+O>?T$TMScNd-J>)Gb;DH+plDkN+R$RP45=;TL\gc[OdnB;<>'d,rqHb?$XrMX:?-?=Dmqj36o#]3?Y.Rdu=:I[6*GTT1KEDbNjUS-[j/eAq&U(pb#TH1ul],F[9AO;6)FU^0ns#(?EVrp]oLY8fEpjBY2SOcbb?IZt5fKpi%iF?]34/YYObkTFDp!8Y]W!<9mC!FhOiT#J^cfZE0;5Z#bp<)dtgT.G$pN%fqsIU<&%FU\?Ho%NTW(V_jj1CR&pYSd/)dk[P&$S,H<JAi77H5?c7T#C>pk"RG%Ht+CZ/Z&.h5KCSsXFHW0Q<-`T9b_"kWm`X2C]gMn/<4$8IcE8$[;tuVCcr<Go+^G',Q'Mu8(iW?7QDFG!*+Utm=skY-.*/Ol52TQZ,7^VDpFOK2H7?1P8"D$1os;)VX=i2&qdk4dIu:OdLV8QQo`6M(o$Q+(%Ku)$[;^nMlI1[a1?Ysq\Kr+Pr8!1SU!:FndA%0-?A%2R.H1KY[pnkKP>U0Vm;)5o-`R"Q6l9RQ/%F-=H\&tY3o4\o(d$d&\c?!`6;[cH'UkF^A:(Bs-mR1o^qSCoAcHU@(\['`Q>fFhSe7L,)])!fb-$2Hp$r9OY0sN9R$L;P_pV4~>endstream
+Gat=+?'!Go'RcT\E?Ek6)k+.)C#Nc.=D=QGbV&!o-0-Cj@`G[*mBks3F0:^U$uE?b)MoZip\UJ%h3;OH9B3d4:%W$b0E4]pc"OGYFHJ+fo,#*pgjHe,LRZI<=jcWm3ltc[o3"2"jUFo4PIKY42KeJ'(0tM<kf'E^P`**bW\i4O=cd;8B>:EL"K=JO:KLLGXd(bCgHoW^p.60pcj*WC2mp83/P;d)>=ao@7(ZO-=HeqT$C=iDM#9i/df2e+0=:PG?ALkl[UfX:MqQQ9S^3n!q5-WmUXb#9h0R5GC[b2DKbFKtn?FZ:R;tW@l-rJi_n#50W2*LD6GaG7Qqb3C_k!b;E(h$jPnZYRmk&Ce6rQiR-W#RH9.*@HdO0_3XU3)5+?[e5/qnrr\*d?Q.8PZg\[Jbs(U]D>#19k7(MGHZg_LP7Md#/qVQhbh!lqkBguO*)Fb/kSV>$e0c8l))HfS'26c_D/UIM8[n?%m3r12haO_Q%EQdA)Bq(:3cMiY>-KIkdLq1Q*I['Hgo_HQ+7B^2GN9i[0GqrjR@0%Vj=`W5f5`nsPlSG*$]q4$.#fJiE`s+>LB@l=GY,A(!hZfs$75=?_M1_i(D#dZg>+\qc(QJ#B+bN7P5&a2UJm++5`)$8SkVh@ND$an_\a5,K1>E^1Fd+QR9S!=7`Hs2;(Su7OB"t"?ci%Q0:9pmuJ6=Bj+(BI?rB098bh*]Q*HnSm]Jq]_JJT&BsCTR%]!Wf3N=Tqt36ifq7nQ\g6>0]f)#m$]R497C'Ir1GQ,>Nf:-;KA:$)bTt<njo)]-H'\.mV?[b8N<[-^bhr7ee2!_!S*HUH'-Zh&!*,%9sppN_f*]Tua1__,&AKjW**JX)5O8!148s:pQu[=N\9k,oRA[NpT2'cjS$3!qKbf!UZh*\Dq\V)+=@m:`<;d1kc=BZ8lSQTktb$@n-UV:o7q/=CktRD/BB@j1hb[-nnIJK+d."04&)4Eg_qqEj<?1an][>e1pG^0THJjHUQpu-k%ZQ)/DV%(YGi/*P!4OPgEp)96;+.gHe=JlN\:fK&mCHU%;;T3t-^.okL8q4FQ)fEHOV:p-Q7Y&gQK^E+$)1!8XFMEO=;I59`EpVug@D;9<-1=jMUpB$,@Q4)%;P-gK2IL$FH(pN$/"A09^?W8Nj3eCYkc#%VT"7Gnr_d6aTNkc50`XQQj>'.30u\#?7qoZE[?ld7_r``-ZWSH"a=V?q\A4nlH)'s=@@(elToP!J`5#lH(sh/>4O4M:KsH2-n.oDSQqT0IaOQdc0H#6A$[CV7>L#YoqVZ2[==Jj9F;H()`JV("+0I`eQ'GGV2/DQK_gHK:Rk[9(jK]/(u`CTqXReI=@M*D:1>?>9'<g[@K_Dj/hTPD3-_8g7S%r4i<!Ng)_bIK-+[p9aa&PM\bL-3N:TKs`ef.l%31p@Bf[Yh.=V"#JlJ>gCLId8p$N9+=c)4c0kL8F2389F&n9HH!qBbOs$==s$K@K&u!!S^eQ@<4p<,$'-oWR-?AlmW6@S`ENo,G1qhjpWIb/*E"QeCqORP1cn0X?pYg,dQo8N"?f^)qn,b9TrmhofUCF*autq[D"e$9@Ws:S^_SM.>ZY;oT8hi=G!X:0B>BDf^.rR$*ru]9XD_$0k)8m`,Q'NGNg]!\k#i<_HgsqCJ"Vj"QKd9X];*Dn0_=ZL(b\ZjEH88DJ`;%PU5I+ofa9a2@Qa2o:RBBWVOR#s\)\2~>endstream
 endobj
 40 0 obj
 <<
@@ -380,13 +380,13 @@ xref
 0000031508 00000 n 
 0000033571 00000 n 
 0000035980 00000 n 
-0000037869 00000 n 
-0000039405 00000 n 
-0000040090 00000 n 
+0000037783 00000 n 
+0000039319 00000 n 
+0000040004 00000 n 
 trailer
 <<
 /ID 
-[<17101b4e73c42ad3c69edb43bada0062><17101b4e73c42ad3c69edb43bada0062>]
+[<2660fd7697f16929a9fb0502e2c01140><2660fd7697f16929a9fb0502e2c01140>]
 % ReportLab generated PDF document -- digest (http://www.reportlab.com)
 
 /Info 23 0 R
@@ -394,5 +394,5 @@ trailer
 /Size 43
 >>
 startxref
-41712
+41626
 %%EOF

PUBLICATION_PLAN.md

@@ -1,27 +0,0 @@
-# Publication Plan
-
-This is the Ouroboros-authored, authority-bound release plan. Current state: **PAUSED / PRIVATE REVIEW STAGE**.
-
-## Gate 1 — private staging
-
-Assemble the manuscript, 49-kernel replay, 36-source lock, registered-artifact disposition audit, falsifiers, result atlas, licenses, citation metadata, review PDF, and complete SHA manifest in a new immutable local directory. Keep all upload and public-action flags false.
-
-## Gate 2 — clean-room replay
-
-From an empty cache, retrieve public source archives, verify every SHA, run all derivations, emit fresh results before reading references, compare generated payloads, and require adversarial source/result mutations to fail.
-
-## Gate 3 — operator review
-
-The operator reviews scientific wording, attribution, token-range labeling, PAUSED status, licenses, PDF layout, and the distinction between public replay code and private Ouroboros access. Any substantive mathematical expansion creates a new immutable version.
-
-## Gate 4 — release candidate
-
-Only after explicit operator instruction: rebuild from clean inputs, regenerate the manifest and PDF, run the publication claim and privacy guards, and create a new private Hugging Face repository through the authenticated API path. Private upload does not authorize public visibility.
-
-## Gate 5 — public promotion
-
-Only the operator may authorize changing visibility. Promotion follows remote SHA verification and a final no-secret/no-local-path scan. The release must remain labeled PAUSED and must preserve the Ouroboros AI System credit.
-
-## Rollback and stop conditions
-
-The private stage is immutable. A failed gate does not mutate it; corrections go into a new version. Stop on source-hash drift, a replay mismatch, a failing falsifier, a missing artifact hash, a privacy leak, an attribution defect, or absent operator release authority.

README.md

@@ -15,10 +15,10 @@ tags:
 
 This repository is staged privately for operator review and is designed for a future public research release. Repository visibility must remain private until the operator explicitly changes it.
 
-The package contains 49 portable derivation kernels, a SHA-pinned lock for 36 public arXiv source archives, 49 derivation tests, a registered-artifact disposition audit, independent compute/compare/falsifier commands, a comprehensive paper, a result atlas, licenses, citation metadata, a rendered review PDF, and a complete manifest.
+The package contains 49 portable derivation kernels, a SHA-pinned lock for 36 public arXiv source archives, 49 derivation tests, a registered-artifact disposition audit, independent compute/compare/falsifier commands, a comprehensive paper, a result atlas, licenses, machine-readable citation metadata, and a complete manifest.
 
-Start with `REPLAY_STANDARD.md` and `VALIDATION.md`, then review `PAPER.md`, `RESULT_ATLAS.md`, and `PUBLICATION_PLAN.md`.
+Start with `VALIDATION.md` and `REPLAY_STANDARD.md`, then read `PAPER.md` and `RESULT_ATLAS.md`.
 
-Required credit: **Ouroboros AI System**.
+`PAPER.md` and `PAPER.pdf` are the same paper: the Markdown file is browser-readable source and the PDF is its rendered copy. Both live at repository root so they cannot be mistaken for different manuscripts.
 
-The dataset-card license describes the generated research data and prose. Replay code is separately licensed under `LICENSE-CODE`; third-party papers remain under their original terms and are retrieved from their public source URLs rather than redistributed here.
+Human-readable attribution, licensing, access, and no-endorsement terms are consolidated in `ATTRIBUTION_AND_USE.md`. `CITATION.cff` exists only for citation software, while `NOTICE` is the concise legal notice preserved with redistributed code. Third-party papers remain under their original terms and are retrieved from public source URLs rather than redistributed here.

VALIDATION.md

@@ -1,7 +1,19 @@
-# Pre-release Clean-room Validation
+# Validation
 
 Status: **PASSED** for the replay scope; publication remains **PAUSED / PRIVATE REVIEW**.
 
+## Pre-release clean-room replay
+
 The pre-release validation began from a target declared absent by the admitted operation contract, fetched and SHA-verified all 36 public source archives, and ran 51 tests (49 derivation tests plus two boundary tests). It then generated all 49 scientific payloads before reference comparison. Every payload matched, and all source-corruption, result-mutation, and expected-answer-isolation falsifiers passed.
 
 `validation/clean_room_replay_receipt.json` binds these results to the exact replay/test/reference/source-lock file tree in this candidate. The receipt itself is provenance evidence; evaluators should still run the commands in `REPLAY_STANDARD.md` because receipt checking alone is not scientific replay.
+
+## Independent private-Hub download replay
+
+Ouroboros also exercised the evaluator path from the uploaded private Hugging Face repository. It downloaded the pinned commit into a newly absent destination, created a new virtual environment from `requirements.txt`, began with an empty source cache, fetched and SHA-verified 36 of 36 public source archives, passed 51 of 51 tests, generated 49 fresh scientific payloads, and matched all 49 only after generation. Source corruption, result mutation, and expected-answer-isolation falsifiers all passed.
+
+The first external validation attempt downloaded the complete repository but stopped in the validator because it expected a manifest field named `size_bytes`; the release manifest correctly uses `byte_count`. The downloaded repository itself had not failed. Ouroboros corrected only the external validator and repeated the entire download into a second absent destination. That repeat passed every inventory, manifest, source, test, compute, comparison, and falsifier gate.
+
+As an additional isolation test beyond the documented commands, computation was rerun while runtime access to the entire `references/` tree was forcibly denied. All 49 payloads were generated with zero reference-file opens. They were byte-identical to the normal fresh outputs and matched all 49 reference assertions afterward.
+
+These results validate scientific replay from public inputs. They do not replay the preceding autonomous research campaign.

ouroboros_replay/kernels/crystal_ledger.py

@@ -1,5 +0,0 @@
-"""Portable compatibility shim; public replay never writes the private capability ledger."""
-from __future__ import annotations
-
-def register_crystal_artifacts(*args, **kwargs):
-    return {"status": "portable_replay_ledger_disabled"}

ouroboros_replay/kernels/run_sabrina_ads_radiation_spectral_commutator.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -10,7 +14,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('1a1275f84b2989c1956ca93f60d06baee3e055215413dbb77fba34ba28e0fbf2')
@@ -74,36 +77,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'symbolic_identity_exact': certificate['symbolic_residual'] == '0', 'rational_witnesses_all_pass': certificate['rational_witness_count'] == 96 and (not certificate['rational_witness_failures']), 'nonzero_commuting_counterexample': all(certificate['nonzero_commuting_pair'].values()), 'misaligned_pair_detected': certificate['misaligned_pair']['commutator_nonzero']})
     return {'result_version': 'sabrina_ads_radiation_spectral_commutator_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2404.02146', 'title': 'Radiation in Holography'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'spectral_identity': certificate['identity'], 'no_radiation_algebraic_condition': 'the proposed super-Poynting criterion vanishes exactly when Cotton-York and stress commute', 'interpretation': 'the criterion measures eigenframe misalignment, weighted by Cotton eigenvalue gaps', 'nonzero_not_sufficient': 'nonzero Cotton-York and nonzero stress are necessary but not sufficient for a nonzero commutator'}, 'spectral_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_ads_radiation_criterion_rigorously_proved': False, 'local_cut_criterion_constructed': False, 'cotton_cft_dictionary_constructed': False, 'flat_limit_rederived': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'ads_radiation_spectral_commutator_report.json'
-    certificate_path = out_dir / 'ads_radiation_spectral_certificate.json'
-    handoff_path = out_dir / 'ADS_RADIATION_SPECTRAL_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'spectral_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# AdS radiation spectral commutator - private handoff\n\nFor real symmetric boundary Cotton-York and stress tensors, the squared commutator norm is exactly $2\\sum_{i<j}(c_i-c_j)^2T_{ij}^2$. The proposed radiation diagnostic therefore measures eigenframe misalignment; nonzero tensors can remain non-radiative when they commute, including mixing within degenerate Cotton eigenspaces. This algebraic theorem does not establish the physical AdS radiation proposal itself.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_ads_radiation_spectral_commutator_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_ads_two_interval_scattering_feasibility.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a')
@@ -71,36 +74,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_ads_two_interval_scattering_feasibility_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2411.10527', 'title': "Cryptographic tests of the python's lunch conjecture"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'nonempty_scattering_domain': 'pi/2 <= mu <= arccos(-1/3) and tau_*(mu) <= tau <= pi-mu', 'linear_onset': '2 sqrt((3+cos(mu))/(1-cos(mu))) epsilon', 'quadratic_onset': '((1+cos(mu))/(1-cos(mu))) epsilon^2', 'endpoint': 'at cos(mu)=-1/3 the tau interval collapses and the formal coefficients are 2 sqrt(2), 1/2'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'pure_ads_2_plus_1_only': True, 'small_positive_epsilon_interior_required': True, 'general_geometry_claimed': False, 'quantum_correction_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'ads_two_interval_scattering_feasibility_report.json'
-    witness_path = out_dir / 'ads_two_interval_scattering_feasibility_witnesses.json'
-    handoff_path = out_dir / 'ADS_TWO_INTERVAL_SCATTERING_FEASIBILITY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# AdS two-interval scattering feasibility - private handoff\n\nCombining the paper's domain and scattering inequalities gives the exact nonempty parameter window mu in [pi/2, arccos(-1/3)] and tau in [tau_*, pi-mu]. The mutual-information area turns on with explicit linear and quadratic coefficients at tau=tau_*+epsilon. The endpoint collapses the tau interval, so its coefficients are formal one-sided limits. No general-geometry, quantum-correction, or publication claim is made.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_ads_two_interval_scattering_feasibility_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_all_even_d_ward_normalization.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import gzip
 import hashlib
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('e0aab59e43f1b3bcc32b6723491cd79b62a04087bd25ef83736a712a2d7d7b70')
@@ -74,36 +77,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'future_coefficient_universally_minus_half': future == -sp.Rational(1, 2), 'past_coefficient_universally_plus_half': past == sp.Rational(1, 2), 'soft_difference_universally_minus_one': soft_difference == -1, 'ward_coefficient_universally_closes': ward_total == 0, 'finite_m2_through_m10_close': all((row['hard_plus_soft'] == '0' for row in finite_rows))})
     return {'result_version': 'sabrina_all_even_d_ward_normalization_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1502.07644', 'title': "Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem", 'dimension_scope': 'd=2m+2 with integer m>=2'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, **source}, 'universal_certificate': {'future_soft_insertion_over_hard_imbalance': str(future), 'past_soft_insertion_over_hard_imbalance': str(past), 'soft_ward_difference_over_hard_imbalance': str(soft_difference), 'hard_plus_soft_ward_coefficient': str(ward_total)}, 'finite_exact_rows': finite_rows, 'classification': 'all_even_d_soft_hard_ward_normalization_exact_and_m_independent', 'label_audit': {'duplicate_label': 'scgen', 'occurrence_count': 2, 'blocks_distinct': True, 'classification': 'latex_cross_reference_ambiguity_only', 'physics_error_claimed': False}, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'source_physics_correction_claimed': False, 'sphere_differential_identity_rederived': False, 'odd_spacetime_dimensions_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'all_even_d_ward_normalization_report.json'
-    certificate_path = out_dir / 'all_even_d_ward_normalization_certificate.json'
-    handoff_path = out_dir / 'ALL_EVEN_D_WARD_NORMALIZATION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({'generated_utc': generated, 'universal_certificate': report['universal_certificate'], 'finite_exact_rows': report['finite_exact_rows'], 'label_audit': report['label_audit'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# All-even-dimensional Ward normalization - private handoff\n\nFor every d=2m+2 with integer m>=2, all m-dependent factors cancel: the future soft insertion is -1/2 of the hard imbalance, the past insertion is +1/2, and the Ward difference is -1, exactly canceling the hard coefficient. The two distinct soft-charge formulas share the label scgen; this is a LaTeX cross-reference ambiguity, not a physics error.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_all_even_d_ward_normalization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'decompressed_source.tex': SOURCE_MEMBER_SHA256, **{key: spec[2] for key, spec in SOURCE_BLOCK_SPECS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_all_m_transverse_nonlocality_chain.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -58,29 +62,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'generic_nonvanishing_slice_exact': sp.simplify(nonvanishing_slice - expected_slice) == 0, 'm_minus_2_boundary_cancels_exactly': sp.simplify(core.subs(r, m - 2) - 4 * (a - b)) == 0, 'order_zero_has_exact_Z2_factor': sp.simplify(generic.subs(r, 0) / z ** 2).has(z) is False, 'generic_order_has_exact_Z_r_plus_2_factor': sp.simplify(generic / z ** (r + 2)).has(z) is False, 'last_order_has_exact_Z_m_plus_1_factor': sp.simplify(last / z ** (m + 1)).has(z) is False, 'minimal_depth_identity': sp.simplify(m - 1 - 2 - (m - 3)) == 0, 'finite_m3_through_m8_depth_ladder': all((row['minimal_inverse_total_Z_depth'] == row['m'] - 3 for row in finite_rows)), 'finite_m3_through_m8_multiplicities': all((item['total_Z_multiplicity'] == item['r'] + 2 and item['nonzero'] for row in finite_rows for item in row['rows'])), 'finite_difference_termination_identities': all(finite_difference_checks), 'm3_m4_m5_progression': [row['minimal_inverse_total_Z_depth'] for row in finite_rows[:3]] == [0, 1, 2]})
     return {'result_version': 'sabrina_all_m_transverse_nonlocality_chain_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'sources': {'celestial_conformal_colliders': {'arxiv_id': '2211.14287', 'title': 'Celestial Conformal Colliders'}, 'detector_operators': {'arxiv_id': '2307.16801', 'title': 'Detector Operators for Celestial Symmetries'}, 'infinite_symmetry_algebras': {'arxiv_id': '2607.28718', 'title': 'Infinite Symmetry Algebras in Four-Dimensional Conformal Field Theories'}}, 'source_evidence': {'archive_sha256': SOURCE_HASHES, **source}, 'theorem': {'domain': 'integer m>=3 in the complex-Hermitian conformal-scalar conventions', 'minimal_inverse_total_Z_depth': 'd_min(m)=m-3', 'generic_distribution_orders': 'for 0<=r<=m-2, R_(m,r) has exact total-Z multiplicity r+2', 'last_nonzero_order': 'r=m-1 has exact total-Z multiplicity m+1', 'vanishing_orders': 'R_(m,r)=0 for r>=m', 'progression': 'm=3 -> 0, m=4 -> 1, m=5 -> 2, then the all-m proof'}, 'finite_exact_rows': finite_rows, 'classification': 'all_m_transverse_nonlocality_depth_saturation_and_distribution_order_multiplicity_exact', 'exact_checks': exact_checks, 'claim_boundary': {'boundary_condition_analysis_complete': False, 'independent_second_derivation_complete': False, 'public_replay_claim_allowed': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'all_m_transverse_nonlocality_chain_report.json'
-    certificate_path = out_dir / 'all_m_transverse_nonlocality_chain_certificate.json'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({'generated_utc': generated, 'theorem': report['theorem'], 'finite_exact_rows': report['finite_exact_rows'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path]
-    manifest = {'manifest_version': 'sabrina_all_m_transverse_nonlocality_chain_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'status': report['status'], 'public_actions_allowed': False}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    return {'status': report['status'], 'artifact_count': 3, 'manifest_sha256': _sha256(manifest_path), 'public_actions_allowed': False}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_ambidextrous_integer_prefactor_lattice.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -10,7 +14,6 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('2427287be8bd1a7795678aaa741678883d650e87fafd311bdbed06d30af1418a')
@@ -108,37 +111,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'ambidextrous_integer_prefactor_lattice_report.json'
-    witness_path = out_dir / 'ambidextrous_integer_prefactor_witnesses.json'
-    handoff_path = out_dir / 'AMBIDEXTROUS_INTEGER_PREFACTOR_LATTICE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Ambidextrous integer-prefactor lattice - private handoff\n\nThe symmetric sine and antisymmetric cosine light-transform prefactors have a complete complementary integer-weight pattern. Positive integers select one finite channel and one zero. At nonpositive integers, a trigonometric zero cancels the gamma pole in one channel while the other retains a simple pole; Delta zero and one have explicit finite values and residues. This classifies scalar prefactors, not the complete regulated distributional wavefunctions.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_ambidextrous_integer_prefactor_lattice_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_boundary_soft_scale_cocycle.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('9449818f67f5ea56945c7389f382057b410a452e387ea285b0b1e23e079fbe7b')
@@ -83,37 +86,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'boundary_soft_scale_cocycle_report.json'
-    witness_path = out_dir / 'boundary_soft_scale_witnesses.json'
-    handoff_path = out_dir / 'BOUNDARY_SOFT_SCALE_COCYCLE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Boundary soft scale cocycle - private handoff\n\nThe arbitrary positive scale in the corrected boundary two-point function changes only a delta-supported contact term. The shift is an exact additive cocycle in log scale; it vanishes on test functions whose coincidence value is zero, leaves separated points unchanged, and drops out of the log-time derivative. This does not make the coincident correlator regulator independent.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_boundary_soft_scale_cocycle_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_carrollian_celestial_weyl_intertwiner.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
@@ -88,36 +91,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_carrollian_celestial_weyl_intertwiner_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2501.00462', 'title': 'Multiparticle States for the Flat Hologram'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'all_orders_transform': 'Z_nu[u^m partial_u^r Phi]=Gamma(nu)/Gamma(nu-m) Z_(nu+r-m)[Phi]', 'polynomial_reduction': 'Gamma(nu)/Gamma(nu-m)=product_(j=1)^m(nu-j)', 'weyl_intertwining': 'D=T_+ and U=(nu-1)T_- obey [D,U]=1', 'derivative_normalization': 'Z_nu[partial_u^r Phi]=Z_(nu+r)[Phi] with unit coefficient'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'vanishing_boundary_terms_required': True, 'analytic_continuation_outside_convergence_strip_required': True, 'distributional_contour_prescription_claimed': False, 'physical_null_state_interpretation_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'carrollian_celestial_weyl_intertwiner_report.json'
-    witness_path = out_dir / 'carrollian_celestial_weyl_intertwiner_witnesses.json'
-    handoff_path = out_dir / 'CARROLLIAN_CELESTIAL_WEYL_INTERTWINER_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Carrollian-celestial Weyl intertwiner - private handoff\n\nThe Gamma-normalized null-time transform sends partial_u to a unit upward Mellin shift and u to a weighted downward shift. These operators obey the Weyl commutator exactly, yielding a closed all-orders formula for every normal-ordered u^m partial_u^r. Vanishing boundary terms are required; analytic continuation is needed outside the convergence strip. No distributional-contour, physical-null-state, or publication claim is made.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_carrollian_celestial_weyl_intertwiner_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_carrollian_conglomerate_kernel_stratification.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
@@ -83,36 +86,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_carrollian_conglomerate_kernel_stratification_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2501.00462', 'title': 'Multiparticle States for the Flat Hologram'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'generic_locus': 'the published coefficient vector spans the kernel exactly when both chiral weight pairs are nonzero', 'boundary_locus': 'if exactly one chiral pair vanishes the kernel is two-dimensional; if both vanish it is four-dimensional', 'precise_correction': 'the scalar-multiple uniqueness statement requires the nonzero-pair hypothesis'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_admissibility_of_zero_weight_strata_claimed': False, 'null_state_quotient_claimed': False, 'interacting_spectrum_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'carrollian_conglomerate_kernel_stratification_report.json'
-    witness_path = out_dir / 'carrollian_conglomerate_kernel_stratification_witnesses.json'
-    handoff_path = out_dir / 'CARROLLIAN_CONGLOMERATE_KERNEL_STRATIFICATION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Carrollian conglomerate kernel stratification - private handoff\n\nThe four Lorentz-primary coefficient equations factor as a two-sided annihilation problem for a 2x2 coefficient matrix. The published vector is the unique generator only when both chiral weight pairs are nonzero. If one pair vanishes, the kernel has dimension two; if both vanish, it has dimension four. This is an exact domain completion of the stated scalar-multiple uniqueness result. No claim about physical admissibility, null-state quotients, interacting spectra, or publication is made.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_carrollian_conglomerate_kernel_stratification_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_causal_interior_inclusion_lemma.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -8,7 +12,6 @@ import tarfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('17edb31380f6f0e8856d0f3541a36ab4a6023551894698a45dbf44e7a37991e0')
@@ -78,36 +81,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'finite_push_up_models_nonempty': certificate['finite_chain_models_checked'] > 0, 'finite_push_up_models_all_pass': certificate['violation_count'] == 0, 'dropping_interior_has_countermodel': certificate['dropped_interior_countermodel']['both_inclusions_fail'], 'countermodel_failure_is_reflexive_point': certificate['dropped_interior_countermodel']['future_missing_points'] == [1] and certificate['dropped_interior_countermodel']['past_missing_points'] == [1]})
     return {'result_version': 'sabrina_causal_interior_inclusion_lemma_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2509.26264', 'title': 'On sufficient conditions for holographic scattering'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'hypotheses': 'M is a time-oriented spacetime and A is a subset of the manifold interior of B', 'future': 'J^+(A) is contained in I^+(B), hence in the interior of J^+(B)', 'past': 'J^-(A) is contained in I^-(B), hence in the interior of J^-(B)', 'proof': 'for a in A choose b_- << a and b_+ >> a inside B; push-up gives b_- << y from a <= y and y << b_+ from y <= a', 'boundary_corollary': 'if J^+(A) (respectively J^-(A)) is closed, then its boundary lies in that causal set and is disjoint from the boundary of J^+(B) (respectively J^-(B))'}, 'relation_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'conformal_boundary_extension_proved': False, 'closedness_automatic_without_causal_assumption': False, 'full_connected_wedge_theorem_reproved': False, 'n_to_n_extension_proved': False, 'mixed_state_extension_proved': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'causal_interior_inclusion_report.json'
-    certificate_path = out_dir / 'causal_interior_relation_certificate.json'
-    handoff_path = out_dir / 'CAUSAL_INTERIOR_INCLUSION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'relation_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Causal-interior inclusion lemma - private handoff\n\nThe causal inclusion expected in arXiv:2509.26264 follows from a local timelike perturbation and the push-up lemma: $A\\subset\\operatorname{int}B$ implies $J^\\pm(A)\\subset I^\\pm(B)\\subset\\operatorname{int}J^\\pm(B)$. The boundary-disjointness step additionally needs the relevant $J^\\pm(A)$ to be closed, as in causally simple settings. No conformal-boundary or full connected-wedge extension is claimed.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_causal_interior_inclusion_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_cdqs_amplification_singleton_obstruction.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -10,7 +14,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('cbeaadef653abc7c51e2c763ac8c01ae7628c881c294903e367361e2704ac3c8')
@@ -71,36 +74,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'chosen_code_violates_singleton': singleton['chosen_parameters_impossible'], 'formal_chosen_exponent_is_negative': exponent['chosen_alpha_would_decay'], 'feasible_endpoint_exponent_positive': exponent['endpoint_positive'], 'endpoint_sign_reduced_exactly': exponent['endpoint_sign_equivalent_to_256e_gt_300'], 'base_error_exceeds_feasible_critical_value': exponent['base_error_above_critical'], 'dense_feasible_interval_all_positive': certificate['rational_feasible_witness_count'] == 250 and (not certificate['rational_feasible_witness_failures']), 'iid_threshold_has_nonempty_feasible_overlap': certificate['threshold_applicable_witness_count'] > 0})
     return {'result_version': 'sabrina_cdqs_amplification_singleton_obstruction_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2404.14491', 'title': 'Conditional disclosure of secrets with quantum resources'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'result': {'singleton_obstruction': 'the alpha=0.495, beta approximately 0.838 code used in the proof cannot correct arbitrary t-qubit errors', 'exponent_obstruction': 'after enforcing alpha<=1/4, the cited i.i.d. bound has positive rather than negative asymptotic exponent at epsilon=0.09', 'repair_classes': ['first reduce the one-qubit base error below the feasible coding threshold', 'replace the cited arbitrary-error code/i.i.d. estimate with a compatible threshold theorem', 'supply a different amplification construction not requiring the inconsistent parameters']}, 'obstruction_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'amplification_impossible_by_all_methods': False, 'cdqs_amplification_theorem_disproved': False, 'corrected_amplification_constructed': False, 'external_primary_source_locally_hash_pinned': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'cdqs_amplification_singleton_obstruction_report.json'
-    certificate_path = out_dir / 'cdqs_amplification_singleton_certificate.json'
-    handoff_path = out_dir / 'CDQS_AMPLIFICATION_SINGLETON_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('result', 'obstruction_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# CDQS amplification Singleton obstruction - private handoff\n\nThe amplification proof's $t=0.495m$, positive-rate arbitrary-error code violates the quantum Singleton bound $k\\leq m-4t$. Enforcing the feasible range $t/m\\leq1/4$ also makes the cited i.i.d. estimate grow rather than decay at base error $0.09$. This identifies a proof-path obstruction and repair requirements; it does not show that CDQS amplification is impossible by another construction.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_cdqs_amplification_singleton_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_cdqs_fidelity_envelope_strengthening.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a')
@@ -69,36 +72,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'threshold_order_exact': thresholds['exp_minus_one_less_than_half'], 'active_margin_positive': thresholds['margin_floor_positive'], 'dense_rational_witnesses_all_pass': certificate['rational_witness_count'] == 400 and (not certificate['rational_witness_failures']), 'parameter_witnesses_all_pass': all((row['strengthened_ge_displayed'] for row in certificate['parameter_witnesses']))})
     return {'result_version': 'sabrina_cdqs_fidelity_envelope_strengthening_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2411.10527', 'title': "Cryptographic tests of the python's lunch conjecture"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'parameter': 'a=d_Q^(-1/2)+delta+epsilon>0', 'strengthened_bound': 'I(A:B)_Psi >= max{0,-2 ln(2a)}', 'derivation': 'the proof gives F<=2a and I>=-2 ln F; universal F<=1 gives F<=min(1,2a)', 'comparison': 'the strengthened envelope strictly exceeds the displayed -ln(a)-1 lower bound for every a>0'}, 'envelope_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'alpha_zero_resolved': False, 'finite_secret_dependence_removed': False, 'correctness_security_dependence_removed': False, 'complexity_mutual_information_conjecture_proved': False, 'python_lunch_conjecture_proved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'cdqs_fidelity_envelope_report.json'
-    certificate_path = out_dir / 'cdqs_fidelity_envelope_certificate.json'
-    handoff_path = out_dir / 'CDQS_FIDELITY_ENVELOPE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'envelope_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# CDQS fidelity-envelope strengthening - private handoff\n\nThe proof in arXiv:2411.10527 directly implies $I(A:B)\\geq\\max\\{0,-2\\ln(2a)\\}$ for $a=d_Q^{-1/2}+\\delta+\\epsilon$. This strictly dominates the displayed $-\\ln(a)-1$ bound for every positive $a$, by retaining the proof's factor of two and using $F\\leq1$. It does not remove finite-secret or error dependence, determine $\\alpha_0$, or prove the complexity conjecture.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_cdqs_fidelity_envelope_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_celestial_circle_convex_hull_certificate.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('1268f6f1bc7479f48f32e0611e1aefae14149a7f4cdb5d858365165da08f6849')
@@ -85,36 +88,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'celestial_circle_convex_hull_report.json'
-    certificate_path = out_dir / 'celestial_circle_certificate_examples.json'
-    handoff_path = out_dir / 'CELESTIAL_CIRCLE_CONVEX_HULL_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_examples', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Celestial-circle convex-hull certificate - private handoff\n\nThe circle selection rule is equivalent to strict separation of the incoming and outgoing convex hulls in the embedded celestial sphere. A strict rational hyperplane certifies separation; an equal convex combination certifies intersection, with at most four points per side by Caratheodory in $\\mathbb R^3$. Exact finite data are covered; floating degeneracy and amplitude dynamics are not.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_celestial_circle_convex_hull_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_celestial_eikonal_logarithm_gauge.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('eb03e2135b623ef961155841b0f1fb48f90fc86e47b8d8ccd3f73c7b4174522b')
@@ -90,37 +93,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'celestial_eikonal_logarithm_gauge_report.json'
-    witness_path = out_dir / 'celestial_eikonal_logarithm_gauge_witnesses.json'
-    handoff_path = out_dir / 'CELESTIAL_EIKONAL_LOGARITHM_GAUGE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Celestial Eikonal logarithm gauge - private handoff\n\nFor the null ordered-pair Eikonal bilinear, every leg-separable additive change of the logarithm reduces exactly to row contractions with total signed momentum. Momentum conservation therefore removes the full ambiguity. The converse yields the row contractions; total momentum conservation follows only with a spanning/nondegeneracy condition, and a parallel-null counterexample proves that condition cannot be dropped.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_celestial_eikonal_logarithm_gauge_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_celestial_euclidean_monodromy_cancellation.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('d1ffa83185733baeb25b8254be688a99db0101bf43540afc8980c1cf2f8f9ff0')
@@ -67,36 +70,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'euclidean_cancellation_exact': certificate['euclidean_scalar_cancels'], 'rational_euclidean_grid_passes': certificate['rational_euclidean_witness_count'] > 100 and (not certificate['rational_euclidean_witness_failures']), 'generic_off_locus_nontrivial': certificate['generic_off_locus_witness']['nontrivial'], 'integer_spin_single_valued': all((row['trivial'] for row in certificate['integer_spin_rows']))})
     return {'result_version': 'sabrina_celestial_euclidean_monodromy_cancellation_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2309.16602', 'title': 'Multicollinear Singularities in Celestial CFT'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'paired_monodromy': 'eta^alpha bar-eta^beta acquires exp(2 pi i(alpha-beta)) under opposite winding', 'euclidean_scalar': 'for beta=alpha the paired monodromy is exactly one', 'complexified_obstruction': 'with bar-eta fixed, eta^alpha retains exp(2 pi i alpha), generically obstructing contour pulling', 'integer_spin_extension': 'paired Euclidean monodromy is single-valued whenever alpha-beta is an integer'}, 'monodromy_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'branch_term_vanishes': False, 'complexified_branch_cut_removed': False, 'hard_celestial_jacobi_restored': False, 'full_ope_associativity_reproved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'celestial_euclidean_monodromy_report.json'
-    certificate_path = out_dir / 'celestial_monodromy_certificate.json'
-    handoff_path = out_dir / 'CELESTIAL_MONODROMY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'monodromy_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Celestial Euclidean monodromy cancellation - private handoff\n\nPaired opposite winding gives monodromy $e^{2\\pi i(\\alpha-\\beta)}$, so scalar Euclidean branch factors cancel exactly while a complexified contour holding $\\bar\\eta$ fixed retains generic holomorphic monodromy. Local Euclidean single-valuedness therefore coexists with the double-residue contour obstruction; the branch term is not removed.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_celestial_euclidean_monodromy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_celestial_momentum_rising_factorial.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46')
@@ -72,36 +75,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'all_product_formulas_exact': all((row['product_formula_matches'] for row in rows)), 'all_recurrences_exact': all((row['recurrence_matches'] for row in rows)), 'all_normalized_shift_ratios_exact': all((row['coefficient_ratio_matches'] for row in rows)), 'source_order_two_factor_exact': bool(sp.simplify(rising_prefactor(2, delta) - source_factor) == 0), 'divisor_rows_exact': all((row['pole_order_at_delta_zero'] == max(row['order'] - 1, 0) and len(row['simple_prefactor_zeros']) == max(row['order'] - 1, 0) for row in rows))})
     return {'result_version': 'sabrina_celestial_momentum_rising_factorial_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2012.15694', 'title': 'Shifting Spin on the Celestial Sphere'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'all_order_identity': 'P_(mu1)...P_(mur) phi^Delta = [(Delta)_r/Delta^r] product_i K^Delta_(mui) phi^Delta', 'initial_values': 'R_0(Delta)=R_1(Delta)=1', 'recurrence': 'R_(r+1)(Delta)=R_r(Delta)(1+r/Delta)', 'product_form': 'R_r(Delta)=product_(j=1)^(r-1)(Delta+j)/Delta^(r-1) for r>=2', 'divisor': 'R_r has a pole of order r-1 at Delta=0 and simple zeros at Delta=-1,...,-(r-1)', 'source_special_case': 'R_2=(Delta+1)/Delta=1+1/Delta'}, 'all_order_proof': {'shift_iteration': 'P^r contributes q_(mu1)...q_(mur) phi^(Delta+r)', 'normalized_wavefunction_ratio': 'phi^(Delta+r)/phi^Delta=(Delta)_r/(-q dot X)^r', 'fixed_K_product': 'product_i K^Delta_(mui)=Delta^r product_i q_(mui)/(-q dot X)^r', 'division_step': 'the coefficient ratio is (Delta)_r/Delta^r'}, 'exact_rows': rows, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'interacting_amplitude_validity_claimed': False, 'on_shell_operator_subtleties_resolved': False, 'singular_weight_factors_separately_evaluable': False, 'analytic_continuation_required_at_divisor': True, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'celestial_momentum_rising_factorial_report.json'
-    witness_path = out_dir / 'celestial_momentum_rising_factorial_witnesses.json'
-    handoff_path = out_dir / 'CELESTIAL_MOMENTUM_RISING_FACTORIAL_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'all_order_proof', 'exact_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Celestial momentum rising-factorial law - private handoff\n\nThe source's two-momentum factor extends to every number of celestial momentum insertions through a rising-factorial prefactor. Its recurrence and complete meromorphic divisor are exact. At singular conformal weights the prefactor and momentum product must not be evaluated separately without analytic continuation. No interacting-amplitude, on-shell-resolution, physical singular-state, or publication claim is made.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_celestial_momentum_rising_factorial_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_celestial_recursion_pde_generating_function.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('bb41217149756d1b5a56ca91fd7a5c99c511d0be8b8e54f15c900914c712bd77')
@@ -91,37 +94,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'celestial_recursion_pde_generating_function_report.json'
-    witness_path = out_dir / 'celestial_recursion_pde_generating_witnesses.json'
-    handoff_path = out_dir / 'CELESTIAL_RECURSION_PDE_GENERATING_FUNCTION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Celestial-recursion PDE generating function - private handoff\n\nThe infinite coefficient tower in the displayed p-indexed PDEs is a complete homogeneous polynomial sequence. It has a two-pole rational generating function, a second-order recurrence, and a removable coincident-kinematics limit. Consequently the termwise Taylor identities resum on the amplitude to one rational kernel. This is a formal-series statement on the amplitude, not a claim that the differential operator freely commutes with its kinematic coefficients.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_celestial_recursion_pde_generating_function_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_coulomb_branch_complexity_ratio.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
@@ -62,36 +65,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_coulomb_branch_complexity_ratio_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'universal_ratio': 'C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]', 'manifest_minimum': 'ratio=1/2+(p-3)^2/[16(9-p)]', 'physical_bounds': '1/2 <= C_flat/C_throat <= 9/16 for p=0,1,2,3,4', 'maximal_reduction': 'p=3 uniquely gives a one-half fractional complexity reduction', 'parameter_cancellation': 'R, r_p, G_10, Omega_(8-p), and V_p cancel from the ratio'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'complexity_equals_volume_only': True, 'physical_integer_p_zero_through_four_only': True, 'complexity_equals_action_claimed': False, 'field_theory_circuit_complexity_equality_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'coulomb_branch_complexity_ratio_report.json'
-    witness_path = out_dir / 'coulomb_branch_complexity_ratio_witnesses.json'
-    handoff_path = out_dir / 'COULOMB_BRANCH_COMPLEXITY_RATIO_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Coulomb-branch complexity ratio - private handoff\n\nNormalizing the flat-bubble Complexity=Volume result by the corresponding throat value cancels every geometric and coupling prefactor. For physical p=0 through 4, the ratio lies between one-half and nine-sixteenths; p=3 uniquely maximizes the fractional reduction at one-half. No Complexity=Action, exact field-theory circuit-complexity, or publication claim is made.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_coulomb_branch_complexity_ratio_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_detector_sum_identity_correction.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0')
@@ -88,36 +91,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'derivative_falling_factorial_holds_through_order_12': all(derivative_checks), 'falling_negative_to_rising_positive_holds_through_order_12': all(convention_checks), 'source_local_identity_holds_on_full_0_through_12_grid': all((row['source_local_matches'] for row in grid_rows)), 'source_local_kprime2_cutoff2_is_six': counterexample_row['source_local_falling_sum'] == '6', 'v1_rising_misread_kprime2_cutoff2_is_four': counterexample_row['rising_misread_sum'] == '4', 'displayed_final_kprime2_cutoff2_is_six': counterexample_row['displayed_final'] == '6', 'symbolic_recurrence_residual_is_zero': recurrence_residual == 0, 'symbolic_base_case_is_one': sp.binomial(kp, 0) == 1})
     return {'result_version': 'sabrina_detector_sum_identity_convention_reaudit_v2', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2307.16801', 'title': 'Detector Operators for Celestial Symmetries'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'main_tex_sha256': SOURCE_MEMBER_SHA256, **source}, 'convention_certificate': {'source_local_notation': 'falling_factorial(a,n)=Gamma(a+1)/Gamma(a-n+1)', 'derivative_rule': 'd^n omega^a / d omega^n = falling_factorial(a,n) omega^(a-n)', 'sign_conversion': 'falling_factorial(-kprime,n)(-1)^n = rising_factorial(kprime,n)', 'closed_form': 'sum rising_factorial(kprime,n)/n! = binomial(kprime+K,K)', 'symbolic_recurrence_residual': str(recurrence_residual)}, 'kprime2_cutoff2': counterexample_row, 'grid_rows': grid_rows, 'classification': 'v1_false_positive_superseded_source_local_falling_factorial_identity_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'supersession': {'predecessor_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'predecessor_claim_valid': False, 'reason': 'v1 interpreted source-local falling-factorial notation as standard rising Pochhammer', 'predecessor_artifacts_mutated': False}, 'claim_boundary': {'source_equation_correction_established': False, 'downstream_physics_correction_established': False, 'notation_ambiguity_requires_erratum': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'detector_sum_identity_convention_reaudit_report.json'
-    certificate_path = out_dir / 'detector_sum_identity_convention_reaudit_certificate.json'
-    handoff_path = out_dir / 'DETECTOR_SUM_IDENTITY_CONVENTION_REAUDIT_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('convention_certificate', 'kprime2_cutoff2', 'supersession', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Detector sum identity convention re-audit - private handoff\n\nThe v1 correction claim is superseded. In the source-local derivative convention, (a)_n is the falling factorial Gamma(a+1)/Gamma(a-n+1). Therefore (-k')_n(-1)^n is the rising factorial (k')_n, and the displayed finite sum equals the displayed binomial exactly. At k'=2 and K=2 the source-local sum is 6; the value 4 came only from applying the wrong rising convention to the first symbol. No source or downstream physics correction is established. The immutable v1 package remains unchanged as audit evidence.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_detector_sum_identity_convention_reaudit_manifest_v2', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'main.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'supersedes_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_electromagnetic_memory_detector_tradeoff.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('7713c97d18c7b5ac41c1cb8884d73bddd6d1639551b3e91aef46d1a715fe67e4')
@@ -76,36 +79,3 @@ def build_exact_result() -> dict[str, Any]:
     checks.update(fluence['checks'])
     checks.update(brownian['checks'])
     return {'result_version': 'sabrina_electromagnetic_memory_detector_tradeoff_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1505.00716', 'title': 'Asymptotic Symmetries and Electromagnetic Memory'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'endpoint_identity': 'sigma Delta x=Q M-m Delta v', 'rest_endpoint_memory': 'Delta x=Q M/sigma', 'fixed_memory_fluence_bound': 'Phi>=M^2/T', 'constant_ramp_tradeoff': 'Phi=M^2/T and SNR^2=Q^2 Phi/(2 kBT sigma)'}, 'endpoint_memory_certificate': endpoint, 'fluence_certificate': fluence, 'brownian_tradeoff_certificate': brownian, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'linear_drag_only': True, 'rest_endpoints_required_for_shape_independence': True, 'quadratic_fluence_proxy_only': True, 'brownian_result_overdamped_equilibrium_white_noise_only': True, 'experimental_feasibility_claimed': False, 'arbitrary_noise_or_nonlinear_drag_claimed': False, 'full_electromagnetic_energy_normalization_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'electromagnetic_memory_detector_tradeoff_report.json'
-    witness_path = out_dir / 'electromagnetic_memory_detector_tradeoff_witnesses.json'
-    handoff_path = out_dir / 'ELECTROMAGNETIC_MEMORY_DETECTOR_TRADEOFF_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'endpoint_memory_certificate', 'fluence_certificate', 'brownian_tradeoff_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Electromagnetic-memory detector tradeoff - private handoff\n\nThe viscous-bead proposal extends to the full linear damped equation through an exact endpoint correction. Rest endpoints make displacement depend only on integrated field. A constant slow ramp minimizes quadratic fluence, but in the stated overdamped thermal model its Brownian SNR falls in direct proportion to that fluence. No experimental-feasibility or general-noise claim is made.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_electromagnetic_memory_detector_tradeoff_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_entanglement_scattering_slack_identity.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
@@ -67,36 +70,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in certificate['residuals'].values())), 'equality_iff_all_slacks_zero': all((row['gap_zero'] == row['all_slacks_zero'] for row in certificate['equality_grid'])), 'numerical_witness_exact': certificate['numerical_witness']['gap'] == certificate['numerical_witness']['expected_gap'], 'numerical_witness_geometric': certificate['numerical_witness']['all_primitive_areas_positive']})
     return {'result_version': 'sabrina_entanglement_scattering_slack_identity_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'regime': "the paper's warm-up entanglement-scattering configuration and its stated focusing/minimality assumptions", 'identity': 'S_gen(s_ent)-I(V_1;V_2)=(sigma_ent+delta_min+sigma_lift+sigma_slope)/(4 G_N)', 'positivity': 'all four slacks are nonnegative when G_N>0', 'saturation': 'equality holds if and only if all four slacks vanish'}, 'symbolic_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'general_configuration_reproved': False, 'matter_entropy_terms_rederived': False, 'quantum_task_dual_constructed': False, 'flat_space_limit_extended': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'entanglement_scattering_slack_identity_report.json'
-    certificate_path = out_dir / 'entanglement_scattering_slack_certificate.json'
-    handoff_path = out_dir / 'ENTANGLEMENT_SCATTERING_SLACK_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Entanglement-scattering slack identity - private handoff\n\nIn the paper's warm-up regime, the difference between generalized wedge entropy and mutual information is exactly the sum of four nonnegative geometric slacks divided by $4G_N$. Saturation requires entanglement-ridge focusing, trial-surface minimality, lift focusing, and slope focusing all to saturate simultaneously. This does not extend the proof to unrestricted configurations or construct the proposed quantum-task interpretation.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_entanglement_scattering_slack_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_flat_boundary_corner_rank_drop.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
@@ -63,36 +66,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_flat_boundary_corner_rank_drop_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'finite_scale_bijection': 'det(J_ell)=-ell^-4 and rank(J_ell)=8 for ell nonzero', 'exact_reconstruction': 'all eight endpoint variables are recovered by the exact affine inverse at finite ell', 'flat_rank_drop': 'rank(lim_(ell->infinity) J_ell)=4', 'lost_subspace': 'the limiting kernel is exactly span(v_c1,v_c2,u_r1,u_r2)', 'interpretation': 'the strict flat boundary-corner data retain angular geometry but erase all four endpoint times'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'kinematic_affine_map_only': True, 'strict_flat_limit_only': True, 'interacting_dynamics_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'flat_boundary_corner_rank_drop_report.json'
-    witness_path = out_dir / 'flat_boundary_corner_rank_drop_witnesses.json'
-    handoff_path = out_dir / 'FLAT_BOUNDARY_CORNER_RANK_DROP_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Flat boundary-corner rank drop - private handoff\n\nAt finite AdS scale, the eight diamond-corner coordinates exactly reconstruct all eight endpoint times and angles. The strict flat limit drops the map's rank from eight to four: its kernel is precisely the four endpoint-time directions, while angular data remain. This is a source-pinned kinematic theorem; no interacting-dynamics or publication claim is made.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_flat_boundary_corner_rank_drop_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_inverted_mellin_equivalence.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5')
@@ -65,37 +68,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks.update({'source_asymptotic_prefactor': r_phi_prefactor == -1 / (2 * u), 'raw_inversion_measure': sp.simplify(raw_measure - 1 / (2 * tau)) == 0, 'positive_half_line_orientation': sp.simplify(oriented_measure + 1 / (2 * tau)) == 0, 'negative_half_line_orientation': sp.simplify(oriented_measure + 1 / (2 * tau)) == 0, 'canonical_rescaling_measure': sp.simplify(2 / (2 * t) - 1 / t) == 0, 'regulator_rescales_by_two': regulator_factorization == 0, 'displayed_power_of_two': sp.simplify(derived_coefficient - displayed_coefficient) == 0, 'displayed_argument': transformed_argument == -t * q, 'outgoing_negative_branch_phase': sp.simplify(phase_from_lower_lip - outgoing_phase) == 0})
     status = 'complete' if all(exact_checks.values()) else 'failed'
     return {'result_version': 'sabrina_inverted_mellin_equivalence_v1', 'status': status, 'paper': {'arxiv_id': '2310.02186', 'title': 'Equating Extrapolate Dictionaries for Massless Scattering', 'equation_label': 'eq:intgrlequiv'}, 'source_evidence': {key: value for key, value in source.items() if key != 'checks'}, 'derivation': {'null_infinity_asymptotic': 'r Phi -> -(2u)^-1 tildePhi(-qhat/(2u))', 'first_variable': 'tau=1/u on each open half-line', 'oriented_measure': 'du[-1/(2u)] -> -d tau/(2 tau)', 'canonical_variable': 't=tau/2=(2u)^-1', 'weight_identity': '(1/(2t)-i epsilon)^(-Delta)=2^Delta(1/t-2i epsilon)^(-Delta)', 'final_prefactor': '-2^(Delta-1)', 'final_argument': '-t qhat', 'regulator_rename': 'epsilon_t=2 epsilon>0', 'negative_u_branch': '(u-i0)^(-Delta)=|u|^(-Delta) exp(i pi Delta)'}, 'classification': 'source_equation_consistent_normalization_rescaling_made_explicit', 'finding': 'The displayed equivalence is exact. The prose change t=u^-1 suppresses the subsequent positive rescaling t=(2u)^-1 and regulator rename; it does not create a normalization or branch error.', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'parents': {'corpus_selection_result_sha256': CORPUS_SELECTION_RESULT_SHA256, 'source_archive_sha256': SOURCE_ARCHIVE_SHA256, 'source_member_sha256': SOURCE_MEMBER_SHA256}, 'claim_boundary': {'paper_correction_claimed': False, 'physics_beyond_source_equivalence_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'inverted_mellin_equivalence_report.json'
-    certificate_path = out_dir / 'inverted_mellin_equivalence_certificate.json'
-    handoff_path = out_dir / 'INVERTED_MELLIN_EQUIVALENCE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate = {'generated_utc': generated, 'classification': report['classification'], 'derivation': report['derivation'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}
-    certificate_path.write_text(json.dumps(certificate, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Inverted Mellin equivalence - private handoff\n\nThe displayed normalization and outgoing branch phase are exact. The missing step in the prose is the positive rescaling from tau=1/u to t=tau/2, together with epsilon_t=2 epsilon. This is a derivation clarification, not a correction to the paper or a new physics claim.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_inverted_mellin_equivalence_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'eq:intgrlequiv': SOURCE_EQUATION_SHA256}, 'parents': report['parents'], 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_late_time_three_cut_null_test.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import itertools
@@ -10,7 +14,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
@@ -104,36 +107,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'Hminus_affine_residual_zero': minus_residual == 0, 'Hzero_affine_residual_zero': zero_residual == 0, 'quadratic_residual_factors_as_e_times_vandermonde': sp.simplify(quadratic_residual - curvature * vandermonde) == 0, 'symbolic_quadratic_coefficient_recovered': reconstructed_curvature == curvature, 'all_60_rational_rows_exact': len(rational_rows) == 60 and all((row['exact'] and row['affine_null'] for row in rational_rows)), 'all_six_permutations_recover_same_curvature': all(permutation_checks), 'repeated_cuts_rejected': repeated_rejected})
     return {'result_version': 'sabrina_late_time_three_cut_null_test_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'null_residual': '(u2-u3)H(u1)+(u3-u1)H(u2)+(u1-u2)H(u3)', 'affine_result': 'zero for pairwise distinct cuts', 'quadratic_factorization': str(quadratic_residual), 'quadratic_reconstruction': 'e=residual/[(u1-u2)(u1-u3)(u2-u3)]', 'permutation_invariant_ratio': True}, 'finite_exact_rows': rational_rows, 'classification': 'late_time_three_cut_affine_null_test_and_quadratic_curvature_extraction_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'nonzero_residual_means_non_affine_only': True, 'physical_cause_identified_from_residual': False, 'higher_than_quadratic_contamination_reconstructed': False, 'pairwise_distinct_cuts_required': True, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'late_time_three_cut_null_test_report.json'
-    certificate_path = out_dir / 'late_time_three_cut_null_test_certificate.json'
-    handoff_path = out_dir / 'LATE_TIME_THREE_CUT_NULL_TEST_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Late-time three-cut null test - private handoff\n\nEach affine-u coefficient in Eq. latetime obeys an exact three-cut Vandermonde null test. A quadratic contamination produces the residual e(u1-u2)(u1-u3)(u2-u3), so e is recovered exactly for distinct cuts. The ratio is permutation invariant. A nonzero residual establishes only a departure from affine-u behavior; it does not identify a physical cause.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_late_time_three_cut_null_test_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivsr.tex': SOURCE_MEMBER_SHA256, 'eq_latetime': SOURCE_EQUATION_SHA256}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_late_time_two_cut_reconstruction.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
@@ -99,36 +102,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'symbolic_Y3_reconstruction_exact': recovered['Y3'] == y3, 'symbolic_F2_reconstruction_exact': recovered['F2'] == f2, 'symbolic_LF2_reconstruction_exact': recovered['LF2'] == lf2, 'symbolic_V1_reconstruction_exact': recovered['V1'] == v1, 'fixed_origin_cross_order_residual_zero': fixed_origin_residual == 0, 'origin_shift_minus_intercept_covariant': shifted_minus_intercept == -2 * f2 - tau * y3, 'origin_shift_zero_intercept_covariant': shifted_zero_intercept == 2 * v1 + tau * lf2, 'shifted_residual_is_tau_La_over_two': shifted_residual == tau * la / 2, 'all_30_rational_reconstructions_exact': len(rational_rows) == 30 and all((row['reconstruction_exact'] for row in rational_rows)), 'coincident_cuts_rejected': coincident_rejected})
     return {'result_version': 'sabrina_late_time_two_cut_reconstruction_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'source_form': 'Hminus(u)=-u Y3-2F2; Hzero(u)=u LF2+2V1', 'two_cut_slope': '[H(u2)-H(u1)]/(u2-u1)', 'two_cut_intercept': '[u2 H(u1)-u1 H(u2)]/(u2-u1)', 'recovered_images': {name: str(value) for name, value in recovered.items()}, 'fixed_origin_cross_order_relation': 'slope(Hzero)+one_half L(intercept(Hminus))=0', 'origin_shift_law': "under v=u-tau: slopes fixed, b'=b+tau a, d'=d+tau c", 'shifted_cross_order_residual': str(shifted_residual), 'origin_invariance_extra_condition': 'L(a)=0'}, 'finite_exact_rows': rational_rows, 'classification': 'late_time_two_cut_image_reconstruction_exact_with_origin_covariance', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'sphere_operator_inversion_claimed': False, 'sphere_operator_kernels_resolved': False, 'global_modes_reconstructed': False, 'intercepts_origin_invariant_claimed': False, 'cross_order_relation_origin_invariant_without_La_zero_claimed': False, 'distinct_cuts_required': True, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'late_time_two_cut_reconstruction_report.json'
-    certificate_path = out_dir / 'late_time_two_cut_reconstruction_certificate.json'
-    handoff_path = out_dir / 'LATE_TIME_TWO_CUT_RECONSTRUCTION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Late-time two-cut reconstruction - private handoff\n\nAny two distinct absolute-u cuts reconstruct the four affine coefficients in Eq. latetime and therefore the differential images Dbar^3Ybar, Dbar^2f, (D^2-2)Dbar^2f, and Dbar Vbar. The shared f-image yields a fixed-origin cross-order consistency equation. Under a change of u origin, slopes are invariant but intercepts transform covariantly; the residual shifts by tau L(a)/2 and is invariant only if L(a)=0. No sphere operator is inverted.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_late_time_two_cut_reconstruction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivsr.tex': SOURCE_MEMBER_SHA256, 'eq_latetime': SOURCE_EQUATION_SHA256, 'interpretation_context': SOURCE_CONTEXT_SHA256}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_logarithmic_mellin_pole_order_correction.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('507d405bf10b9686f8fbc678b9a7eaaa73c6f45b4f68e59edbcaecddd7ecfcc4')
@@ -76,36 +79,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update({'finite_laurent_rows_exact': all((row['all_coefficients_match'] for row in rows)), 'pole_order_is_log_power_plus_one': all((row['pole_order'] == row['log_power'] + 1 for row in rows)), 'leading_factorial_coefficient_exact': all((row['leading_coefficient'] == (-1) ** row['log_power'] * int(sp.factorial(row['log_power'])) for row in rows)), 'highest_pole_scale_invariant': all(scale_checks), 'source_one_loop_double_pole_reproduced': reconciliation['one_loop_derivative_identity'] and reconciliation['one_loop_double_pole_coefficient'] == -1, 'source_two_minus_k_bound_reconciled': reconciliation['two_minus_k_reconciles']})
     return {'result_version': 'sabrina_logarithmic_mellin_pole_order_correction_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2202.11127', 'title': 'Goldilocks Modes and the Three Scattering Bases'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'integral_identity': 'I_r(s;Lambda,mu)=(partial_s-log(mu))^r[Lambda^s/s], s=Delta+m', 'exact_principal_part': 'sum_(j=0)^r binom(r,j)(-log(mu))^(r-j)(-1)^j j!/s^(j+1)', 'pole_order': 'a nonzero omega^m[log(omega/mu)]^r term produces a pole of exact order r+1 at Delta=-m', 'leading_coefficient': '(-1)^r r!, independent of Lambda and mu', 'scale_boundary': 'changing mu mixes lower poles but cannot change the highest pole or its coefficient', 'source_correction': "the generic ell-loop sentence requires pole order ell+1 rather than ell; this agrees with the source's one-loop double pole and order 2-k statement"}, 'all_order_proof': {'analytic_split': 'Lambda^s/s=s^-1+an analytic function at s=0', 'derivative_rule': 'partial_s^j(s^-1)=(-1)^j j! s^(-j-1)', 'binomial_rule': 'expand (partial_s-log(mu))^r and apply the derivative rule termwise'}, 'finite_exact_rows': rows, 'source_reconciliation': reconciliation, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'uv_completion_claimed': False, 'full_amplitude_reconstructed': False, 'existing_smooth_amplitude_residue_theorem_duplicated': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'logarithmic_mellin_pole_order_correction_report.json'
-    witness_path = out_dir / 'logarithmic_mellin_pole_order_correction_witnesses.json'
-    handoff_path = out_dir / 'LOGARITHMIC_MELLIN_POLE_ORDER_CORRECTION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'all_order_proof', 'finite_exact_rows', 'source_reconciliation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Logarithmic Mellin pole-order correction - private handoff\n\nA soft term with log power r gives a Mellin pole of order r+1, not r. The highest-pole coefficient is exact and scale independent; a logarithm-scale change mixes only lower poles. This corrects the generic loop-order sentence while agreeing with the source's explicit one-loop double pole and its later 2-k bound. No full-amplitude, UV, or publication claim is made.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_logarithmic_mellin_pole_order_correction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_low_hard_generator_nonclosure.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import gzip
 import hashlib
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('56dd48c217761e4cfc914fc3480831c01049a5e34b6ed4ef11893fc445964043')
@@ -71,36 +74,3 @@ def build_exact_result() -> dict[str, Any]:
     checks.update(commutator['checks'])
     checks.update(modes['checks'])
     return {'result_version': 'sabrina_low_hard_generator_nonclosure_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1407.3814', 'title': "Low's Subleading Soft Theorem as a Symmetry of QED"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'commutator': '[X_Y,X_Z]=-E^-1 D_z(Y partial_z Z-Z partial_z Y) partial_E', 'angular_component': 'zero', 'closure_obstruction': 'the commutator is in the same X_U family only when the displayed covariant derivative vanishes', 'monomial_modes': 'for Y=z^m,Z=z^n and Gamma=0, the coefficient is -(n-m)(m+n-1)z^(m+n-2)/E'}, 'commutator_certificate': commutator, 'monomial_certificate': modes, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'hard_scalar_truncation_only': True, 'full_soft_plus_hard_algebra_failure_claimed': False, 'massless_qed_context_only': True, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'low_hard_generator_nonclosure_report.json'
-    witness_path = out_dir / 'low_hard_generator_nonclosure_witnesses.json'
-    handoff_path = out_dir / 'LOW_HARD_GENERATOR_NONCLOSURE_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'commutator_certificate', 'monomial_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Low hard-generator nonclosure - private handoff\n\nThe hard scalar operator family extracted from the massless-QED Ward identity is not generically closed: its commutator is a pure energy derivative controlled by the covariant derivative of the vector-field bracket. Forty of the 49 monomial pairs through degree six are nonclosing. This does not claim failure of the full soft-plus-hard charge algebra.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_low_hard_generator_nonclosure_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_m3_unclassified_module_construction.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -8,7 +12,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LIGHT_SCALAR_OUT_DIR = Path('.replay_outputs') / 'light_scalar_out_dir'
 GLOBAL_RECURRENCE_OUT_DIR = Path('.replay_outputs') / 'global_recurrence_out_dir'
@@ -254,28 +257,6 @@ def build_light_scalar_result() -> dict[str, Any]:
         raise RuntimeError(f'light-scalar checks failed: {[key for key, value in exact_checks.items() if not value]}')
     return {'schema_version': 'sabrina_m3_light_scalar_module_exclusion_v2', 'status': 'source_local_light_scalar_module_excluded', 'result': {'phi2_local_family_repairs_stress_basis': False, 'c4_forced': '0', 'c3_forced': '0', 'remaining_n2_support': n2_support, 'intrinsic_arbitrary_local_f_no_go_for_source_defined_modules': True, 'k3_executed': False}, 'source_map': {'exception': 'free scalar deviations arise from phi phi with Delta=2', 'general_family': 'int du u^p O^(n), n>=Delta', 'weight_2_0_condition': 'p=n-1 followed by partial_z^2', 'orders_needed_through_r3': [2, 3, 4], 'inverse_bar_lift': 'none is defined by the source for the light-scalar correction family'}, 'candidate_kernels': {name: {f'r{order}': str(value) for order, value in rows.items()} for name, rows in candidates.items()}, 'triangular_exclusion': {'r3': str(combined_r3), 'r2_after_c4_zero': str(combined_r2_after_c4), 'reason': 'After removing the common anti-chiral descendant factor, the target is independent of the individual antiholomorphic momenta. The n=4 quadratic and n=3 linear dependence therefore force their constant coefficients to zero; n=2 cannot reach r2 or r3.'}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'authority': {'plan_guard_hash': CORRECTION_PLAN_GUARD_HASH, 'plan_verifier_hash': CORRECTION_PLAN_VERIFIER_HASH}, 'supersedes': {'manifest_sha256': SUPERSEDED_LIGHT_MANIFEST, 'reason': 'v1 used Z=a-b; the source-authoritative convention is Z=a+b'}, 'claim_boundary': {'source_defined_local_phi2_family_only': True, 'arbitrary_unpublished_inverse_bar_dressings_claimed': False, 'all_theories_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
 
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'm3_unclassified_module_construction_report.json'
-    certificate_path = out_dir / 'm3_unclassified_module_construction_certificate.json'
-    handoff_path = out_dir / 'M3_UNCLASSIFIED_MODULE_CONSTRUCTION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({'generated_utc': generated, 'result': report['result'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# M3 unclassified-module construction — private handoff\n\nThe full finite m=2 stress-tensor basis is exactly inconsistent with the m=3,k=2 defect: rank 3 versus augmented rank 4. The P_u-kernel ambiguities alter r0 only, while the contradiction already occurs at r2. No k3 work was executed.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_m3_unclassified_module_construction_manifest_v2', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'status': report['status'], 'supersedes_manifest_sha256': SUPERSEDED_STRESS_MANIFEST, 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
 def write_light_scalar_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
     if out_dir.exists():
         raise FileExistsError(f'immutable result target already exists: {out_dir}')
@@ -295,7 +276,7 @@ def write_light_scalar_package(out_dir: Path, *, register_ledger: bool) -> dict[
     all_artifacts = [*artifacts, manifest_path]
     ledger: Mapping[str, Any] = {'status': 'skipped'}
     if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+        ledger = _portable_registration_disabled(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
     return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
 
 def write_quadratic_global_recurrence_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
@@ -317,7 +298,7 @@ def write_quadratic_global_recurrence_package(out_dir: Path, *, register_ledger:
     all_artifacts = [*artifacts, manifest_path]
     ledger: Mapping[str, Any] = {'status': 'skipped'}
     if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+        ledger = _portable_registration_disabled(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
     return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
 
 def write_all_m_k2_obstruction_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
@@ -339,7 +320,7 @@ def write_all_m_k2_obstruction_package(out_dir: Path, *, register_ledger: bool)
     all_artifacts = [*artifacts, manifest_path]
     ledger: Mapping[str, Any] = {'status': 'skipped'}
     if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+        ledger = _portable_registration_disabled(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
     return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
 
 def write_all_m_hermitian_k2_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
@@ -361,7 +342,7 @@ def write_all_m_hermitian_k2_package(out_dir: Path, *, register_ledger: bool) ->
     all_artifacts = [*artifacts, manifest_path]
     ledger: Mapping[str, Any] = {'status': 'skipped'}
     if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+        ledger = _portable_registration_disabled(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
     return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
 
 def write_missing_module_conditions_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
@@ -383,20 +364,5 @@ def write_missing_module_conditions_package(out_dir: Path, *, register_ledger: b
     all_artifacts = [*artifacts, manifest_path]
     ledger: Mapping[str, Any] = {'status': 'skipped'}
     if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+        ledger = _portable_registration_disabled(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
     return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', default='')
-    parser.add_argument('--analysis', choices=('stress', 'light-scalar', 'global-recurrence', 'all-m-k2', 'all-m-hermitian-k2', 'missing-module-conditions'), default='stress')
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    defaults = {'stress': OUT_DIR, 'light-scalar': LIGHT_SCALAR_OUT_DIR, 'global-recurrence': GLOBAL_RECURRENCE_OUT_DIR, 'all-m-k2': ALL_M_K2_OUT_DIR, 'all-m-hermitian-k2': ALL_M_HERMITIAN_K2_OUT_DIR, 'missing-module-conditions': MISSING_MODULE_CONDITIONS_OUT_DIR}
-    writers = {'stress': write_package, 'light-scalar': write_light_scalar_package, 'global-recurrence': write_quadratic_global_recurrence_package, 'all-m-k2': write_all_m_k2_obstruction_package, 'all-m-hermitian-k2': write_all_m_hermitian_k2_package, 'missing-module-conditions': write_missing_module_conditions_package}
-    out_dir = Path(args.out_dir) if args.out_dir else defaults[args.analysis]
-    writer = writers[args.analysis]
-    print(json.dumps(writer(out_dir, register_ledger=not args.no_register_crystal_ledger), sort_keys=True))
-    return 0
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_multiparticle_beta_residue_factor_two.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
@@ -94,37 +97,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'multiparticle_beta_residue_factor_two_report.json'
-    witness_path = out_dir / 'multiparticle_beta_residue_witnesses.json'
-    handoff_path = out_dir / 'MULTIPARTICLE_BETA_RESIDUE_FACTOR_TWO_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Multiparticle beta-residue factor-two correction - private handoff\n\nThe literal Euler-beta residue in the paper's displayed Delta variable carries a factor of two omitted from eq:3ptPoles because the pole-bearing gamma argument has slope -1/2. When the two pole towers coalesce, each corrected branch tends to minus twice a central binomial coefficient and their sum exactly equals the collided residue. An unspecified overall kernel normalization could absorb a global factor; it does not alter the literal residue of the displayed beta function.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_multiparticle_beta_residue_factor_two_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_near_extremal_radial_pushforward.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('7553fb8bd01cf4423c26ec5da779dcc70589a21c5c3ee63e95ba43ac08460aa4')
@@ -74,36 +77,3 @@ def build_exact_result() -> dict[str, Any]:
     checks.update(support['checks'])
     checks.update(pushforward['checks'])
     return {'result_version': 'sabrina_near_extremal_radial_pushforward_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1701.00049', 'title': 'Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'inverse': 'c=(rho^2-2 epsilon)/(2 epsilon rho)', 'radial_support': 'rho in [sqrt(epsilon(2+epsilon))-epsilon, sqrt(epsilon(2+epsilon))+epsilon]', 'endpoint_invariants': 'width=2 epsilon, product=2 epsilon, median=sqrt(2 epsilon)', 'pushforward': 'dc=(rho^2+2 epsilon)/(2 epsilon rho^2) drho'}, 'support_map_certificate': support, 'pushforward_certificate': pushforward, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'delta_support_kinematics_only': True, 'mass_family_2_one_plus_epsilon_m_m_m_only': True, 'epsilon_strictly_positive': True, 'full_amplitude_evaluated': False, 'convergence_claimed': False, 'arbitrary_mass_kinematics_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'near_extremal_radial_pushforward_report.json'
-    witness_path = out_dir / 'near_extremal_radial_pushforward_witnesses.json'
-    handoff_path = out_dir / 'NEAR_EXTREMAL_RADIAL_PUSHFORWARD_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'support_map_certificate', 'pushforward_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Near-extremal radial pushforward - private handoff\n\nThe exact finite-epsilon delta-support branch is a monotone angular-to-radial map with an explicit inverse and compact pushforward density. This reduces the angular measure exactly before the near-extremal expansion. It does not evaluate the remaining propagator-dependent amplitude integral.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_near_extremal_radial_pushforward_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'source_lines_303_360': SOURCE_BLOCK[2]}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_p4_spherical_entanglement_expansion.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
@@ -71,36 +74,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in residuals.values())), 'throat_and_flat_eom_exact': residuals['throat_eom'] == residuals['flat_eom'] == '0', 'shell_matching_exact': residuals['shell_value_matching'] == residuals['shell_derivative_matching'] == '0', 'both_regional_integrals_exact': residuals['leading_area'] == residuals['order_P_area'] == '0', 'renormalized_limit_exact': residuals['renormalized_area'] == '0', 'sphere_volume_product_exact': sp.simplify(8 * sp.pi ** 2 / 3 * (2 * sp.pi ** 2) - 16 * sp.pi ** 4 / 3) == 0})
     return {'result_version': 'sabrina_p4_spherical_entanglement_expansion_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'regime': 'p=4, S3 entangling surface, P large, rho=P+s/P+O(P^-3), surface reaches r=0', 'matched_profiles': derivation['profiles'], 'area_over_Omega4_Omega3': 'g P^3(r_uv^2/2-3R^2/10)+g^2 P[-27r_uv/8+81R/35+9R^2/(20r_uv)-27R^4/(200r_uv^3)]+O(P^-1)', 'renormalized_area_over_Omega4_Omega3': '-3gR^2P^3/10+81g^2RP/35+O(P^-1)', 'definitions': 'g=r_4^3 and Omega4*Omega3=16*pi^4/3'}, 'symbolic_derivation': derivation, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'terms_through_order_P_inverse_derived': False, 'finite_P_convergence_proved': False, 'numerical_full_profiles_reproduced': False, 'supergravity_validity_outside_source_domain_claimed': False, 'entropic_c_function_derived': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'p4_spherical_entanglement_expansion_report.json'
-    certificate_path = out_dir / 'p4_spherical_entanglement_expansion_certificate.json'
-    handoff_path = out_dir / 'P4_SPHERICAL_ENTANGLEMENT_EXPANSION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_derivation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# p=4 spherical entanglement expansion - private handoff\n\nThis completes the paper's stated p=4 spherical future-work item at the first two large-P orders. The throat and flat profiles solve the linearized equations exactly, match in value and derivative at the shell, and yield a closed cutoff-dependent and renormalized area through order P. Higher orders, finite-P control, numerical profiles, and the entropic c-function remain outside the claim.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_p4_spherical_entanglement_expansion_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_p4_spherical_refined_entropy.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
@@ -78,36 +81,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in residuals.values())), 'both_t_equations_exact': residuals['throat_t_eom'] == residuals['flat_t_eom'] == '0', 't_shell_matching_exact': residuals['shell_t_value'] == residuals['shell_t_derivative'] == '0', 'P_inverse_area_integral_exact': residuals['integrated_P_inverse'] == '0', 'lower_local_terms_annihilated': residuals['local_P3_and_P_annihilated'] == '0', 'refined_entropy_operator_exact': residuals['refined_entropy'] == '0'})
     return {'result_version': 'sabrina_p4_spherical_refined_entropy_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, 'prior_manifest_sha256': PRIOR_MANIFEST_SHA256, **source}, 'theorem': {'regime': 'p=4, P large, rho=P+s/P+t/P^3+O(P^-5)', 'raw_cutoff_result': derivation['raw_P_inverse_coefficient_over_Omega4_Omega3'], 'refined_operator': '(P*d/dP-1)(P*d/dP-3)/3', 'refined_entropy_area_over_Omega4_Omega3': 'g^3/P*[45/16 log(P/R)+82933/560000]+O(P^-3)', 'infrared_behavior': 'positive for P>=R, tends to zero as log(P/R)/P, and decreases beyond the recorded exact threshold'}, 'symbolic_derivation': derivation, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'normalization_to_field_theory_N_and_G10_fixed': False, 'finite_counterterm_scheme_independence_claimed': False, 'terms_through_order_P_minus_3_derived': False, 'moderate_P_monotonicity_proved': False, 'numerical_profiles_reproduced': False, 'supergravity_domain_extended': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'p4_spherical_refined_entropy_report.json'
-    certificate_path = out_dir / 'p4_spherical_refined_entropy_certificate.json'
-    handoff_path = out_dir / 'P4_SPHERICAL_REFINED_ENTROPY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_derivation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# p=4 spherical refined entropy - private handoff\n\nThe next matched profile correction fixes the complete order-P^-1 area, including the universal logarithm. After the explicit p=4 universal subtraction, the five-dimensional refined operator annihilates the P^3 and P terms and gives a positive asymptotic c-function proportional to [45 log(P/R)/16 + 82933/560000]/P. Its field-theory normalization and finite counterterm scheme remain deliberately unresolved.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_p4_spherical_refined_entropy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'prior_p4_manifest': PRIOR_MANIFEST_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_points_scattering_lower_slack_identity.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
@@ -66,36 +69,3 @@ def build_exact_result() -> dict[str, Any]:
     checks = dict(source['checks'])
     checks.update(algebra['checks'])
     return {'result_version': 'sabrina_points_scattering_lower_slack_identity_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'lower_gap_identity': algebra['gap_identity'], 'slack_meanings': {'delta_max': "S_gen(s_pts'')-S_gen(e_max(s_pts''))", 'delta_focus': "Area(R_pts)/(2G_N)-S_gen(s_pts'')", 'delta_ridge': '[Area(R_reg)-Area(R_pts)]/(2G_N)', 'delta_CWT': 'I(V1;V2)-Area(R_reg)/(2G_N)'}, 'saturation': 'the lower bound saturates if and only if all four source inequalities saturate simultaneously'}, 'symbolic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'semiclassical_entropy_inequalities_only': True, 'new_dynamical_equivalence_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'points_scattering_lower_slack_identity_report.json'
-    witness_path = out_dir / 'points_scattering_lower_slack_identity_witnesses.json'
-    handoff_path = out_dir / 'POINTS_SCATTERING_LOWER_SLACK_IDENTITY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Points-scattering lower-slack identity - private handoff\n\nThe mutual-information lower-bound gap is exactly the sum of four nonnegative slacks: max-wedge contraction, points-ridge focusing, points-to-regions ridge growth, and the CWT ridge bound. Equality therefore requires simultaneous saturation of all four steps. This remains a private, source-pinned semiclassical result.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_points_scattering_lower_slack_identity_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_principal_series_plancherel_factorization.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
@@ -87,36 +90,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'d1_base_is_nu_tanh_over_4pi2': sp.simplify(d1 - nu * sp.tanh(sp.pi * nu) / (4 * sp.pi ** 2)) == 0, 'd2_base_is_nu2_over_4pi3': sp.simplify(d2 - nu ** 2 / (4 * sp.pi ** 3)) == 0, 'all_d1_through_d12_are_shadow_even': all((row['shadow_even'] for row in dimension_rows)), 'all_d1_through_d12_vanish_at_origin': all((row['measure_at_origin_by_limit'] == '0' for row in dimension_rows)), 'all_quadratic_zero_coefficients_positive': all((row['quadratic_zero_coefficient_positive'] for row in dimension_rows)), 'all_ten_dimension_recurrences_exact': all((row['exact'] for row in recurrence_rows)), 'principal_shadow_maps_nu_to_minus_nu': shadow_dimension == sp.Symbol('d', real=True) / 2 - sp.I * nu})
     return {'result_version': 'sabrina_principal_series_plancherel_factorization_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'source_measure': 'Gamma(d/2+i nu)Gamma(d/2-i nu)/(4 pi^(d+1) Gamma(i nu)Gamma(-i nu))', 'dimension_recurrence': 'mu_(d+2)=((d/2)^2+nu^2) mu_d/pi^2', 'even_d_2m': 'nu^2 product_(k=1)^(m-1)(nu^2+k^2)/(4 pi^(2m+1))', 'odd_d_2m_plus_1': 'nu tanh(pi nu) product_(k=0)^(m-1)(nu^2+(k+1/2)^2)/(4 pi^(2m+2))', 'shadow_action': 'nu -> -nu', 'positivity': 'strict for real nu != 0', 'origin': 'quadratic zero obtained by limit, never direct gamma substitution'}, 'dimension_rows': dimension_rows, 'recurrence_rows': recurrence_rows, 'classification': 'principal_series_plancherel_measure_all_integer_d_factorization_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'strict_positivity_at_nu_zero_claimed': False, 'direct_gamma_substitution_at_nu_zero_used': False, 'source_completeness_extended_beyond_assumptions': False, 'off_principal_series_gauge_zero_modes_resolved': False, 'mass_independence_rederived': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'principal_series_plancherel_factorization_report.json'
-    certificate_path = out_dir / 'principal_series_plancherel_factorization_certificate.json'
-    handoff_path = out_dir / 'PRINCIPAL_SERIES_PLANCHEREL_FACTORIZATION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'dimension_rows', 'recurrence_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Principal-series Plancherel factorization - private handoff\n\nThe source gamma-function measure factors exactly in every positive integer celestial dimension. Even dimensions give a positive polynomial in nu^2; odd dimensions give nu tanh(pi nu) times a positive polynomial. The measure is shadow-even, strictly positive for real nonzero nu, vanishes quadratically at nu=0 by a controlled limit, and obeys a one-line d-to-d+2 recurrence.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_principal_series_plancherel_factorization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivps.tex': SOURCE_MEMBER_SHA256, 'shadow_context': SHADOW_CONTEXT_SHA256, **{name: expected for name, (_, expected) in SOURCE_EQUATIONS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_projective_mellin_scale_theorem.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
@@ -70,36 +73,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'symbolic_all_D_all_n_total_is_minus_one': total_real == -1, 'symbolic_full_amplitude_degree_specializes_to_minus_n_at_D4': sp.simplify(full_amplitude.subs(dimension, 4) + multiplicity) == 0, 'symbolic_stripped_degree_specializes_to_4_minus_n': sp.simplify(stripped_amplitude.subs(dimension, 4) - (4 - multiplicity)) == 0, 'D4_principal_mellin_real_weight_vanishes': principal_mellin_real.subs(dimension, 4) == 0, 'D2_through_D12_n2_through_n12_all_cancel': all((row['cancels_to_minus_one'] for row in grid_rows)), 'finite_grid_has_121_points': len(grid_rows) == 121})
     return {'result_version': 'sabrina_projective_mellin_scale_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'principal_series_dimension': 'Delta_i=(D-2)/2+i lambda_i', 'canonical_stripped_amplitude_degree': 'D-n(D-2)/2', 'momentum_delta_degree': '-D', 'projective_jacobian_degree': 'n-1', 'mellin_real_weight_degree': 'n(D-4)/2', 'radial_exponent': '-1+i sum_i lambda_i', 'radial_distribution': 'integral_0^infinity ds s^(-1+i Lambda)=2 pi delta(Lambda)', 'symbolic_real_residual': str(total_real)}, 'source_D4_specialization': d4, 'finite_exact_grid': grid_rows, 'classification': 'all_D_all_n_projective_mellin_radial_scale_cancellation_exact_under_canonical_scaling', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_theorem_dimension_scope': 'D>=3; D=2 retained only as a formal algebraic boundary check', 'massless_canonical_external_scaling_required': True, 'massive_amplitudes_included': False, 'scale_anomalies_included': False, 'noncanonical_external_dimensions_included': False, 'extra_physical_scales_included': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'projective_mellin_scale_theorem_report.json'
-    certificate_path = out_dir / 'projective_mellin_scale_theorem_certificate.json'
-    handoff_path = out_dir / 'PROJECTIVE_MELLIN_SCALE_THEOREM_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'source_D4_specialization', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Projective Mellin scale theorem - private handoff\n\nThe four-dimensional simplex Mellin factorization of arXiv 1706.03917 extends exactly to arbitrary spacetime dimension under canonical massless scaling. The projective Jacobian, principal-series Mellin weights, stripped-amplitude degree, and momentum delta contribute n-1, n(D-4)/2, D-n(D-2)/2, and -D; their real powers sum to -1 for every D and n. The radial integral is therefore 2 pi delta(sum lambda). Massive, anomalous, noncanonical, and extra-scale cases are outside the theorem.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_projective_mellin_scale_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_projective_simplex_positivity_theorem.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
@@ -102,36 +105,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'all_27_witnesses_classify_correctly': all((row['expected_class'] == row['observed_class'] for row in witness_rows)), 'all_cramer_coordinates_match_direct_solve': all((row['cramer_matches_direct'] for row in witness_rows)), 'all_coordinates_have_unit_sum': all((row['unit_sum'] for row in witness_rows)), 'orientation_reversal_preserves_all_coordinates': all((row['orientation_invariant_coordinates'] for row in witness_rows)), 'orientation_reversal_preserves_absolute_jacobian': all((row['orientation_invariant_absolute_determinant'] for row in witness_rows)), 'finite_witness_grid_has_27_rows': len(witness_rows) == 27, 'singular_counterexample_has_zero_determinant': singular.det() == 0, 'singular_counterexample_not_uniquely_localized': singular.rank() < singular.cols})
     return {'result_version': 'sabrina_projective_simplex_positivity_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'scope': 'square invertible augmented matrix M with n=D+1', 'coordinates': 'sigma_i=det(M_i)/det(M), where M_i replaces column i by b=(0,...,0,1)', 'unit_sum': 'the final all-ones row enforces sum_i sigma_i=1', 'interior': 'all signed determinant ratios are strictly positive', 'boundary': 'all ratios are nonnegative and at least one is zero', 'outside': 'at least one ratio is negative', 'distributional_jacobian': 'delta(M sigma-b)=delta(sigma-sigma*)/abs(det M)', 'orientation_invariance': 'common sign reversal of det(M) and det(M_i) leaves ratios and abs(det M) unchanged'}, 'finite_exact_witnesses': witness_rows, 'singular_counterexample': {'D': 4, 'n': 5, 'determinant': str(singular.det()), 'rank': singular.rank()}, 'classification': 'square_projective_simplex_signed_minor_support_and_jacobian_theorem_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'square_n_equals_D_plus_1_only': True, 'invertibility_required': True, 'rectangular_jacobian_claimed': False, 'rank_deficient_unique_localization_claimed': False, 'witness_matrices_claimed_as_physical_null_momenta': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'projective_simplex_positivity_theorem_report.json'
-    certificate_path = out_dir / 'projective_simplex_positivity_theorem_certificate.json'
-    handoff_path = out_dir / 'PROJECTIVE_SIMPLEX_POSITIVITY_THEOREM_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'singular_counterexample', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Projective simplex positivity theorem - private handoff\n\nFor square invertible n=D+1 localization, the simplex coordinates are exact signed determinant ratios. Their signs classify interior, boundary, and outside support, while the localized delta Jacobian is 1/abs(det M). Orientation changes flip numerator and denominator together. Singular and rectangular maps remain outside this theorem.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_projective_simplex_positivity_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_projective_simplex_rank_theorem.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
@@ -83,36 +86,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'all_99_integer_witnesses_have_expected_rank': all((row['full_rank'] for row in grid_rows)), 'finite_grid_has_99_points': len(grid_rows) == 99, 'D4_n2_through_n5_have_zero_affine_moduli': all((row['affine_solution_dimension_on_support'] == 0 for row in d4_rows if row['n'] <= 5)), 'D4_n3_has_two_external_compatibility_constraints': next((row for row in d4_rows if row['n'] == 3))['external_compatibility_codimension'] == 2, 'D4_n4_has_one_external_compatibility_constraint': next((row for row in d4_rows if row['n'] == 4))['external_compatibility_codimension'] == 1, 'D4_n5_is_square_unique_on_support': next((row for row in d4_rows if row['n'] == 5))['external_compatibility_codimension'] == 0, 'D4_n6_has_one_affine_modulus': next((row for row in d4_rows if row['n'] == 6))['affine_solution_dimension_on_support'] == 1, 'rank_deficient_example_is_compatible': rank_deficient.rank() == rank_deficient_augmented.rank() == 2, 'rank_deficient_example_has_one_modulus': len(rank_deficient.nullspace()) == 1, 'incompatible_example_fails_rank_test': incompatible.rank() == 1 and incompatible_augmented.rank() == 2, 'unique_solution_can_fail_simplex_positivity': positivity_counterexample.det() != 0 and list(positivity_solution) == [1, 1, -1]})
     return {'result_version': 'sabrina_projective_simplex_rank_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'constraint_matrix_shape': '(D+1) by n', 'on_support_affine_solution_dimension': 'n-r', 'external_compatibility_codimension': 'D+1-r', 'generic_rank': 'r=min(D+1,n)', 'generic_n_at_most_D_plus_1': 'unique sigma on compatible support; D+1-n residual external constraints', 'generic_n_above_D_plus_1': 'n-D-1 unfixed simplex moduli', 'square_distributional_jacobian': 'for n=D+1 and det(M)!=0 only: delta(M sigma-b)=delta(sigma-sigma*)/abs(det(M))'}, 'finite_exact_grid': grid_rows, 'counterexamples': {'rank_deficient_compatible': {'rank': rank_deficient.rank(), 'nullity': len(rank_deficient.nullspace())}, 'incompatible': {'matrix_rank': incompatible.rank(), 'augmented_rank': incompatible_augmented.rank()}, 'unique_but_not_simplex_positive': {'solution': [str(value) for value in positivity_solution]}}, 'classification': 'all_D_projective_simplex_localization_rank_theorem_exact_with_support_and_positivity_boundaries', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'compatibility_required': True, 'simplex_positivity_required': True, 'rank_deficiency_allowed_but_not_unique': True, 'non_square_distributional_jacobian_derived': False, 'integer_witness_matrices_claimed_as_physical_null_momenta': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'projective_simplex_rank_theorem_report.json'
-    certificate_path = out_dir / 'projective_simplex_rank_theorem_certificate.json'
-    handoff_path = out_dir / 'PROJECTIVE_SIMPLEX_RANK_THEOREM_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'counterexamples', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Projective simplex rank theorem - private handoff\n\nThe paper's five-delta localization statement is the D=4 case of an augmented-matrix rank theorem. For rank r, compatible solutions have dimension n-r and external compatibility has codimension D+1-r. At generic full rank, n<=D+1 fixes the simplex variables on support while leaving D+1-n external constraints; n>D+1 leaves n-D-1 moduli. Rank, compatibility, positivity, and the square-map Jacobian are separate conditions.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_projective_simplex_rank_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, 'localization_statement': LOCALIZATION_LINE_SHA256, **{name: expected for name, (_, expected) in SOURCE_EQUATIONS.items()}}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_quadrupole_spin_memory_cap_duality.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import gzip
 import hashlib
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('baaae174875149f3dd2f3e5e6a6b56b9011e0a608c67eac33d5cb12c238a92f6')
@@ -60,36 +63,3 @@ def build_exact_result() -> dict[str, Any]:
     checks.update(integral['checks'])
     checks.update(duality['checks'])
     return {'result_version': 'sabrina_quadrupole_spin_memory_cap_duality_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1502.06120', 'title': 'New Gravitational Memories'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'cap_response': 'Delta^+u=(12 alpha^2 omega/L)F(x), x=R^2/(1+R^2)', 'polynomial': 'F(x)=x^5/5-x^4/2+x^3/3-x/30', 'factorization': '30F=x(x-1)(2x-1)(3x^2-3x-1)', 'antipodal_complement_duality': 'F(1-x)=-F(x)', 'complete_physical_zero_set': 'x in {0,1/2,1}'}, 'cap_integral_certificate': integral, 'duality_certificate': duality, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'paper_quadrupole_example_only': True, 'centered_stereographic_caps_only': True, 'arbitrary_contours_claimed': False, 'arbitrary_waveforms_claimed': False, 'nonlinear_or_quantum_extension_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'quadrupole_spin_memory_cap_duality_report.json'
-    witness_path = out_dir / 'quadrupole_spin_memory_cap_duality_witnesses.json'
-    handoff_path = out_dir / 'QUADRUPOLE_SPIN_MEMORY_CAP_DUALITY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'cap_integral_certificate', 'duality_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# Quadrupole spin-memory cap duality - private handoff\n\nFor the paper's outgoing quadrupole example, a centered stereographic cap reduces the spin-memory integral to a factored polynomial in its area fraction. Complementary caps have equal and opposite response, and only the empty cap, hemisphere, and full sphere have zero response. This is not a claim about arbitrary contours, waveforms, nonlinear corrections, or quantum gravity.\n", encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_quadrupole_spin_memory_cap_duality_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'decompressed_tex': SOURCE_MEMBER_SHA256, 'source_lines_667_677': SOURCE_BLOCK[2]}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_radial_einstein_square_factorization.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('d91ca33f76b1d78eef4dc241257749edc9c7732b3e3e37c0a016fa2e318b628d')
@@ -62,36 +65,3 @@ def build_exact_result() -> dict[str, Any]:
     checks.update(factorization['checks'])
     checks.update({'factor_kernel_witnesses_exact': all((witnesses[str(power)]['F_coefficient'] == witnesses[str(power)]['F_squared_coefficient'] == 0 for power in (-2, 2))), 'proper_generalized_kernel_witnesses_exact': all((witnesses[str(power)]['F_coefficient'] != 0 and witnesses[str(power)]['F_squared_coefficient'] == 0 for power in (-4, 0)))})
     return {'result_version': 'sabrina_radial_einstein_square_factorization_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.09809', 'title': 'Uplifting AdS3/CFT2 to Flat Space Holography'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'factorization': 'E=[rho^2(D^2-4)+4L]^2, with D=rho partial_rho and L=partial_z partial_zbar', 'operator_identity': 'the published fourth-order radial equation is the exact square of F=rho^2(D^2-4)+4L', 'generalized_kernel_boundary': 'ker(F) is a proper subset of ker(F^2): at L=0, rho^0 and rho^-4 are killed by F^2 but not by F', 'factor_kernel': 'at L=0, rho^2 and rho^-2 are killed already by F'}, 'factorization_certificate': factorization, 'monomial_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'boundary_conditions_analyzed': False, 'physical_mode_admissibility_claimed': False, 'nonlinear_gravity_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'radial_einstein_square_factorization_report.json'
-    witness_path = out_dir / 'radial_einstein_square_factorization_witnesses.json'
-    handoff_path = out_dir / 'RADIAL_EINSTEIN_SQUARE_FACTORIZATION_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'factorization_certificate', 'monomial_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Radial Einstein square factorization - private handoff\n\nThe fourth-order radial operator in the pinned source equation factors exactly as the square of a second-order operator. The square has a strict generalized kernel: two exact radial monomials solve the fourth-order equation without solving the second-order factor. No boundary-condition, physical-mode, nonlinear-gravity, or publication claim is made.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_radial_einstein_square_factorization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_rt_area_boundary_identity.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -10,7 +14,6 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
@@ -88,36 +91,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'off_shell_hamiltonian_identity_exact': certificate['off_shell_identity_residual'] == '0', 'constant_solution_on_shell_witness_exact': certificate['constant_solution_witness_residual'] == '0', 'tail_exponent_identity_symbolic': sp.simplify(alpha ** 2 + beta_squared - b) == 0, 'C3_coefficient_symbolic': sp.simplify(b / (2 * n) - (7 - p) / (9 - p)) == 0, 'derivative_amplitude_saturation_symbolic': certificate['derivative_amplitude_saturation_residual'] == '0', 'physical_p_rows_exact': all((sp.sympify(row['alpha_squared_plus_beta_squared']) == 7 - row['p'] for row in rows)), 'physical_p_beta_real': all((sp.sympify(row['beta_squared']) > 0 for row in rows)), 'displayed_table_equality_exact': all((Decimal(left) == Decimal(right) for left, right in table_pairs)), 'displayed_derivative_constant_sign_mismatch': sp.diff(-sp.Symbol('C3') * sp.Symbol('r_c', positive=True) ** n, sp.Symbol('r_c', positive=True)).could_extract_minus_sign()})
     return {'result_version': 'sabrina_rt_area_boundary_identity_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'exact_boundary_identity': 'A/(K r_c^n)=[H(0)-H(U)]/n=exp(nU) cos(theta(U))^b/(n sqrt(1+theta_dot(U)^2)) for a smooth cap', 'parameters': 'n=(9-p)/2, b=7-p, U=log(r_uv/r_c)', 'resolved_equality': 'C3^(p)=(7-p)/(9-p)*((C1^(p))^2+(C2^(p))^2)', 'mechanism': 'alpha^2+beta^2=7-p fixes the nonoscillatory quadratic boundary term', 'derivative_result': 'the quadratic asymptotic derivative has negative mean and equal oscillation amplitude, hence range [-b(C1^2+C2^2),0]', 'sign_audit': 'd[-C3*r_c^n]/dr_c=-n*C3*r_c^(n-1); the positive displayed constant in source equation DpdA is inconsistent with source equation DpA'}, 'symbolic_certificate': certificate, 'physical_p_rows': rows, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'finite_cutoff_exact_stationary_locations_proved': False, 'higher_asymptotic_orders_cannot_shift_or_lift_zeros_claimed': False, 'full_nonlinear_monotonicity_proved': False, 'numerical_profiles_reproduced': False, 'physical_range_extended_beyond_p_0_through_4': False, 'holographic_prescription_validated': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'rt_area_boundary_identity_report.json'
-    certificate_path = out_dir / 'rt_area_boundary_identity_certificate.json'
-    handoff_path = out_dir / 'RT_AREA_BOUNDARY_IDENTITY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'physical_p_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text("# RT-area boundary identity - private handoff\n\nThe paper's six-decimal coefficient equality follows analytically from an exact on-shell boundary identity. The tail relation alpha^2+beta^2=7-p fixes C3=(7-p)/(9-p)(C1^2+C2^2). At quadratic asymptotic order the area derivative has negative mean and equal oscillation amplitude, explaining monotonicity with recurrent tangencies; finite-cutoff higher-order shifts remain outside the claim. The displayed constant sign in equation DpdA is inconsistent with differentiating the preceding equation DpA.\n", encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_rt_area_boundary_identity_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_soft_charge_cumulant_hierarchy.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -11,7 +15,6 @@ from math import factorial
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('8d7eb8d846a8d632cea6032ceac8553720b36bde75a3ea45bb3d81dfb8882905')
@@ -128,37 +131,3 @@ def _jsonable(value: Any) -> Any:
     if isinstance(value, sp.Basic):
         return str(value)
     return value
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = _jsonable(build_exact_result() | {'generated_utc': generated})
-    report_path = out_dir / 'soft_charge_cumulant_hierarchy_report.json'
-    witness_path = out_dir / 'soft_charge_cumulant_witnesses.json'
-    handoff_path = out_dir / 'SOFT_CHARGE_CUMULANT_HIERARCHY_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Soft-charge cumulant hierarchy - private handoff\n\nThe one- and two-point in-in Ward relations extend algebraically to every connected order. The exact all-n identity retains mixed outgoing-hard/incoming-soft cumulants. Only an additional mixed-cumulant factorization hypothesis reduces it to the two pure cumulants; exact rational witnesses prove both the reduction and its failure when correlations remain. This is a private algebraic result, not a claim that the physical factorization condition has been established.\n', encoding='utf-8')
-    artifacts = [report_path, witness_path, handoff_path]
-    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
-    manifest = {'manifest_version': 'sabrina_soft_charge_cumulant_hierarchy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_soft_charge_reduced_state_theorem.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('cd4abca013519ff0f5500fe09d8b4eb1033df2e33b42f4de32c9325dbae9c2eb')
@@ -82,36 +85,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'witness_normalized': sp.trace(rho_r) == 1 and sp.trace(rho_b) == 1, 'fixed_total_charge_support': all((radiation_charges[r] + horizon_charges[b] == 0 for r, b in support)), 'radiation_commutator_zero': commutator == sp.zeros(4), 'degenerate_sector_coherence_retained': rho_r[1, 2] == sp.Rational(1, 4), 'sector_probabilities_exact': probabilities == [sp.Rational(1, 4), sp.Rational(1, 2), sp.Rational(1, 4)], 'entropy_direct_sum_exact': sp.simplify(radiation_entropy - shannon - weighted_sector_entropy) == 0, 'radiation_entropy_exact': sp.simplify(radiation_entropy - 3 * sp.log(2) / 2) == 0, 'charge_violating_counterexample_normalized': sp.trace(bad_rho_r) == 1, 'counterexample_has_multiple_total_charges': len({radiation_charges[r] + horizon_charges[b] for r, b in bad_support}) == 2, 'counterexample_commutator_nonzero': bad_commutator != sp.zeros(4)})
     return {'result_version': 'sabrina_soft_charge_reduced_state_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2012.03850', 'title': 'HPS meets AMPS: How Soft Hair Dissolves the Firewall'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'hypothesis': 'rho_out is supported in one eigenspace of Q_total=Q_R tensor I + I tensor Q_B', 'conclusion': '[Q_R, Tr_B(rho_out)]=0, with arbitrary degeneracy inside each Q_R sector', 'proof': ['fixed total-charge support implies [Q_total,rho_out]=0', 'partial trace gives [Q_R,rho_R]=Tr_B([Q_total,rho_out])-Tr_B([I tensor Q_B,rho_out])', 'the first term vanishes by the hypothesis and the second by cyclicity of the partial trace on B'], 'entropy_identity': 'S(rho_R)=H({p_q})+sum_q p_q S(rho_q)', 'support_rule': 'nonzero amplitudes obey q_R+q_B=q_total'}, 'witness': {'amplitudes': _matrix_strings(amplitudes), 'rho_r': _matrix_strings(rho_r), 'rho_b': _matrix_strings(rho_b), 'sector_rows': sector_rows, 'shannon_entropy': str(shannon), 'weighted_sector_entropy': str(sp.simplify(weighted_sector_entropy)), 'radiation_entropy': str(radiation_entropy)}, 'necessity_counterexample': {'rho_r': _matrix_strings(bad_rho_r), 'commutator': _matrix_strings(bad_commutator), 'distinct_total_charge_count': 2}, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'unitarity_proved': False, 'information_recovery_proved': False, 'firewall_resolution_proved': False, 'soft_charge_observability_proved': False, 'mixed_total_charge_inputs_covered': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'soft_charge_reduced_state_theorem_report.json'
-    certificate_path = out_dir / 'soft_charge_reduced_state_theorem_certificate.json'
-    handoff_path = out_dir / 'SOFT_CHARGE_REDUCED_STATE_THEOREM_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'witness', 'necessity_counterexample', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Soft-charge reduced-state theorem - private handoff\n\nA fixed additive total soft-charge sector forces the radiation reduced state to be block diagonal in radiation soft charge, while preserving coherence inside degenerate sectors. Its entropy separates exactly into classical charge-sector uncertainty and average within-sector entropy. An exact normalized counterexample shows why fixed total-charge support is necessary.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_soft_charge_reduced_state_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())

ouroboros_replay/kernels/run_sabrina_soft_dressing_factor_two_no_go.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+
 from ..source_runtime import fixture_path, source_path
+
+def _portable_registration_disabled(*args, **kwargs):
+    return {"status": "portable_replay_registration_disabled"}
 import argparse
 import hashlib
 import json
@@ -9,7 +13,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 import sympy as sp
-from .crystal_ledger import register_crystal_artifacts
 OUT_DIR = Path('.replay_outputs') / 'out_dir'
 LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
 SOURCE_ARCHIVE = source_path('113774c03094c55b8c0ea9ccf46c7aed866dc0634a7f5179f42b01a63028acf0')
@@ -84,36 +87,3 @@ def build_exact_result() -> dict[str, Any]:
     exact_checks = dict(source['checks'])
     exact_checks.update({'derivation_linearity_exact': derivation['residual'] == '0', 'lambda_two_changes_nonzero_target': derivation['lambda_two_gap'] != '0', 'half_weight_repair_exact': derivation['half_weight_repair_residual'] == '0', 'central_power_rule_exact_through_12': all((row['residual'] == '0' for row in central['power_rows'])), 'central_exponential_series_exact_through_12': all((value == '0' for value in central['truncated_orders_1_through_12_residuals'])), 'matrix_witness_all_exact': all((value is True for key, value in witness.items() if key != 'base_phi_commutator'))})
     return {'result_version': 'sabrina_soft_dressing_factor_two_no_go_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.19866', 'title': 'Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'assumptions': 'Phi is unchanged and linear in photon modes; the charge action is a derivation; every elementary charge-mode commutator is uniformly scaled by lambda', 'no_go': '[Q,Phi]_lambda=lambda[Q,Phi]_1, so lambda=2 cannot retain a nonzero target dressing commutator', 'wilson_corollary': 'if [Q,Phi] is central, the Wilson-line phase scales by the same lambda', 'necessary_repair_classes': ['rescale dressing weights by 1/lambda', 'add a compensating contribution equal to (1-lambda) times the original target', 'change the soft-mode algebra or projection so uniform scaling no longer applies']}, 'algebraic_certificate': certificate, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'modified_opposite_helicity_brackets_resolved': False, 'preferred_repair_class_selected': False, 'physical_soft_phase_space_constructed': False, 'gravity_extension_rederived': False, 'infrared_finiteness_reproved': False, 'source_inconsistency_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
-
-def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
-    if out_dir.exists():
-        raise FileExistsError(f'immutable result target already exists: {out_dir}')
-    out_dir.mkdir(parents=True)
-    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
-    report = build_exact_result() | {'generated_utc': generated}
-    report_path = out_dir / 'soft_dressing_factor_two_no_go_report.json'
-    certificate_path = out_dir / 'soft_dressing_factor_two_no_go_certificate.json'
-    handoff_path = out_dir / 'SOFT_DRESSING_FACTOR_TWO_NO_GO_PRIVATE_HANDOFF.md'
-    manifest_path = out_dir / 'receipt_manifest.json'
-    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    handoff_path.write_text('# Soft-dressing factor-two no-go - private handoff\n\nAn unchanged dressing exponent linear in photon modes cannot retain its required commutator when every elementary charge-mode commutator is doubled. The Wilson-line phase doubles as well whenever the dressing commutator is central. A half-weight dressing, compensating term, or changed soft algebra/projection is therefore necessary; this theorem classifies the obstruction but does not choose or construct the physical modified-bracket repair.\n', encoding='utf-8')
-    artifacts = [report_path, certificate_path, handoff_path]
-    manifest = {'manifest_version': 'sabrina_soft_dressing_factor_two_no_go_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
-    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
-    all_artifacts = [*artifacts, manifest_path]
-    ledger: Mapping[str, Any] = {'status': 'skipped'}
-    if register_ledger:
-        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
-    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
-
-def main(argv: Sequence[str] | None=None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
-    parser.add_argument('--no-register-crystal-ledger', action='store_true')
-    args = parser.parse_args(argv)
-    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
-    print(json.dumps(result, sort_keys=True))
-    return 0 if result['status'] == 'complete' else 1
-if __name__ == '__main__':
-    raise SystemExit(main())