diff --git a/research/real-packed-tensor-staged-caller/EVIDENCE-SHA256.json b/research/real-packed-tensor-staged-caller/EVIDENCE-SHA256.json new file mode 100644 index 0000000000..1be3c6167c --- /dev/null +++ b/research/real-packed-tensor-staged-caller/EVIDENCE-SHA256.json @@ -0,0 +1,147 @@ +{ + "evidence/canonical-guidance-check-1043.json": "8ace11f86caf121840d3c355d4d0d7c077227819d57369ac90dde86ee394a480", + "evidence/mathematical-guard/real-packing-5095-fit.md": "3b48e1790472a686ac1d7a50673b90fb2f456b5c72d35a85e5f96dbd54febf62", + "evidence/packed-caller-independent-gate-20261023/ATTEMPT2-REVIEW.md": "d67384ea20f5c3d0048725a9e0741374697bbcd881123e9cb4cff157213668a5", + "evidence/packed-caller-independent-gate-20261023/ATTEMPT2-STATIC-RESULT.json": "1069c534be59a28745f4c908279b3a084e247d9935adbfb8a45254802f0e7a57", + "evidence/packed-caller-independent-gate-20261023/POSTRUN-CHECK-RESULT.json": "1a229fa58a1638be6ca051528490849ab89927ebd16d11141133af6ffcfb296e", + "evidence/packed-caller-independent-gate-20261023/POSTRUN-REVIEW.md": "dcc5127be917161e10a2af4275e00c37c38addd0593ddb568fcead496b9f77df", + "evidence/packed-caller-independent-gate-20261023/REVIEW.md": "28b7336df66d17df8d14b35708d0172e01eb85e42eba8aafc35617aea27a0023", + "evidence/packed-caller-independent-gate-20261023/STATIC-RESULT.json": "dba3cb823fb149ba3815c296d8fed3424204fb5e25fa023861d2d0304adb3632", + "evidence/packed-caller-independent-gate-20261023/check_attempt2_static.py": "6af37562b27bc71ef4f44aea03ab85811223147748e292aae8018f1352f1d725", + "evidence/packed-caller-independent-gate-20261023/check_postrun.py": "08905157af4658e335644d116865146305518c2efefb06d1688df74140f2d43c", + "evidence/packed-caller-independent-gate-20261023/check_static.py": "3fdfd73e8fc84b757698fd8e641d01dd86875e699a4088a2aa26f5b4dc82f7ee", + "evidence/pr5095-head-update-0938.json": "8a02999f38b9bbb896dfcaec58fa05e16cdce94d08e0a5f9f4da62efe102bf1d", + "evidence/real-hermitian-closure-20261023/CHILD-CENSUS.json": "4470a3830197f7dc1a2d9cd9fada74b7e7c69f4085f0b2380ce3f431b2e20ea0", + "evidence/real-hermitian-closure-20261023/MANIFEST.json": "621a31f13dd25dff15d0f7462154c4dcecec0f78d8cdeaaa75d7a729f7c2b8d1", + "evidence/real-hermitian-closure-20261023/REPORT.md": "e48171630c801a906199c9586c0688f7dd40163846a5b4abae64d33d941ccd2e", + "evidence/real-hermitian-closure-20261023/SOURCES.json": "a3acb57f95f2b6301fe00246b6c56688b9b253c3bb417cf31c1c7a89d8ef8dfd", + "evidence/real-hermitian-closure-20261023/sources/core__.research-export.json": "d387e4d0a1a43b9b24104f76f8992603d4265bbe447601bea476d492e92e5340", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__SOURCE.json": "63477ee5103e4c1d0d1665bf2d1cfb91af5bcdef59cac6e46f4d6a1579b8eb2e", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__reports__bulk-resampling-tape-transfer.md": "cda26d5aca04b9c824eb6c4f50bee564fb7fa908b09a72e76852df5e0b9d2622", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__reports__downstream-microbox-resampling.md": "9598c236eed7e44ac5eb41cc20f7c23249829e195247d15e2857a34e14222c49", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__reports__downstream-phase-cell-inverse.md": "3cdf492bcb719db4295658604dc202d6a2c5a008b87de43ec54f0107c64db730", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__reports__review-phase-cell-inverse.md": "113927dd4fb77a55a457bd5f6da8cbfc7262d0fbc4e9d708b591a1d632e6caf6", + "evidence/real-hermitian-closure-20261023/sources/core__references__semantic-bulk__rad20__reports__review-reusable-banded-inverse.md": "801359569c92f9d5ddd128b694993a5ac22a468e87bfea478cecc0ee413d058b", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__EVIDENCE.md": "387de11320cf695e8092bb311c4c90ff675d281330d6b6ae0039b3ce486e544e", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__PROOF.md": "e909026dd3f455c35ff28210a0c4ffa232ad8d7633174e481094fd09e2469d7a", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__README.md": "ce063e3796bdcea206959918915826ae75c1bcbd74736913e5b330aa04fb5791", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__SOURCES.json": "d3ac712b80fa771f87c0127eaf22debdb290dc544f0bc7b218912e50a8710966", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__TASK.json": "0e7c13e0b801f09b95d1585067951e779cdcca6391e8c0d19c888af3e2a060d1", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__VERIFY.json": "681d32de565b01c2a253f5c7650916dbbebb00abe871acbb23e02dd22fdb8643", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_axis.py": "d416918d7442c5033e43fba94ccc5ed33badc3aebe90ddd479b0b6c020de9724", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_boundary.py": "02303c11978baa4cbc707afb116b8cdb3314dbb2246fa4fe54dafc585d3e5122", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_axis.py": "b63f883443ade4a4711efeae801f6e59d82f9390669988f80ee6231ca4310ae2", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_boundary.py": "c526df6d0f58ab645ffa24df198e528fd1b91848606f8fcfe90cfa38d44ce05a", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_budget.py": "535f8c90f3e0d2c637ba46845242e9ff12799c4bd79a076253d8815891bd4dd5", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_consumer.py": "ecfa619f3f1eecc9edeed0501216d864f3e311e03e73fe49920659e90ed23485", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_convolution.py": "d0c4d410f0a867beb731582d354c322315cb56c0c88ba97ea09c61ec1ae2aed2", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_exponentials.py": "ba24474f95250cc5816adaf28ca37c1ae0f948c56c0a140e6f3a03d034f69172", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_interior.py": "dcb9235c7de7170dae3408f27b8f8e019d21d5ec31c6cf839ce763f135bc510b", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_ownership.py": "4dbbaa1f8aff4dd6d179447f7a24f456d0230a3c6ce9b945a988987c7ab42942", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_production.py": "08a0b2f4c3dc602ff3d8b98a37351a1910610c0bf1ea18fe7ff5378c373d1024", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_setup.py": "46e234fbadbbf934cb02f609d7aa14355789c42f82e384cf624d31e57bd05a3a", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_sources.py": "0e503821c482ef424e474bd600baf019542fff9fd006417ee539bad017be95f1", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_check_window.py": "34713e5b89ff3ca28621c2ee4dae2c72468407189a37a583fad8210de2a8aaea", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_convolution.py": "57fc34acfef9921d805c8c3bdcd0227e67c2ba6b5114c1b373446680e29e3210", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_core.py": "4b5011528a0aedbfa6a7ff577cee2690581b38544cba301120eaf68e7491b9c7", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_exponentials.py": "f7a27cacbb27c0cfa4a63054e83feba2beae91b3fa9d3c37f903620b3899e67b", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_interior.py": "38ffb65cbb40a60ac8d9b45665e752abc34dd2bf403dbc64c89f25a34b7fc2ae", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_matrix.py": "5bb982c6f36083b646bd5a5ab2ea4059c203fa0cc824e9f28132c0f323824bac", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_page.py": "001f7be5c70fa7d59c4e4c8d59337eab9c4498003d6686bdb4d97a900eb0b85d", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_prepare.py": "38aa123f80c68f7fcb9e60acae79543cf55f6fd37e12a548cffae11a9b50c1e5", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_rationals.py": "6f9a380c8c7b4233c3bc338a6206d65cc85bee2e4f5625c2a212065f04f4b73d", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_rows.py": "821fd15a9b82f182f28055d4b83340e697906203f0728a36dc03196eca13c535", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_sources.py": "c5889a97a11a9c6c6c44deb8a2042498ddc3f55703de15269132b8f198e24b15", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__gaussian_window.py": "d10eb4ac559a5dc3ef4a6178ab4cac7dfdcdb5e84ef8acf372bd22c81ab64996", + "evidence/real-hermitian-closure-20261023/sources/core__research__physical-gaussian-core__verify.py": "ecf183f0f6d71f3845f628fdad4fadb5bbb639c0bf4fe6a8a8b7135ab96b57f0", + "evidence/real-hermitian-closure-20261023/sources/tensor__PROOF.md": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e", + "evidence/real-hermitian-closure-20261023/sources/tensor__tensor_engine.py": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1", + "evidence/real-hermitian-closure-20261023/sources/tensor__tensor_lines.py": "66bac95bdcdf788978d185e2f7508cd74152801f1513c4e5af978ff5983fc511", + "evidence/real-hermitian-closure-20261023/sources/tensor__tensor_plan.py": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3", + "evidence/real-hermitian-closure-20261023/sources/tensor__tensor_sources.py": "cba69b2bc93b7dabbffdbdf07fb41130fde5d65a8f4d344ade52d3a326e30ac0", + "evidence/real-hermitian-closure-20261023/sources/word__.research-export.json": "237ccd34aadda692f73b85277816b76168acaecfe06a12996cce37a7f0925cbc", + "evidence/real-hermitian-closure-20261023/sources/word__references__semantic-bulk__rad20__reports__downstream-microbox-resampling.md": "9598c236eed7e44ac5eb41cc20f7c23249829e195247d15e2857a34e14222c49", + "evidence/real-hermitian-closure-20261023/sources/word__references__semantic-bulk__rad20__reports__downstream-phase-cell-inverse.md": "3cdf492bcb719db4295658604dc202d6a2c5a008b87de43ec54f0107c64db730", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__EVIDENCE.md": "c2314c62bbb1cfc0400dd09875926e1efb0000d1db450a984b2f86253d064997", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__PROOF.md": "5d7e5c3e47c4936023f191ef91ff4015d4786cb4de303d8fd3bef0fcec7a77b0", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__README.md": "0a47858de0cbe7700792b52ee3dcd9ae66f3ad9eb1f99f450515e820ed099dc8", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__SOURCES.json": "bbee0d44186979dd290eb9c5320b27e1f831b47b2f96def6a9a94b0c7616dedc", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__TASK.json": "58da62a12008357de910e95903bebf880db508e5e1aca2f46bdf4943d6e84f17", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__VERIFY.json": "3ae59ee74596d9f9d1ea4a218db6ff16279835ad97ef1f60fa9a789c2d0452f8", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_base.py": "c3cab9b4fbce6be760fa50dd398bdec53292399b6eade0c334a3c7579403f008", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_budget.py": "7390f7132599562b46f871d76b94812372818a3edfa59d2142ec6f5cee03fa65", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_codec.py": "89cf7e9425546a0516f05e80590e355603491c1430f2a9244df33244d98a3aa8", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_failures.py": "004ed9c8f75167eb81eafd64f40896f0f812f3dd8c838fd1ad36a47a3fa59fa4", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_fft.py": "0acb902862f63495d1de44275f9ad9926023ddbae1dc797c1fd9cd4452892212", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_plan.py": "69660593a3d9856f858494552c3ddfc93b47e532f3ca8214ec2e5c8578793da8", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_check_sources.py": "f92b3c7877af9a883cc712edde3c7e75c08e8f08220f2aa5a86c76545fece889", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_codec.py": "d13f25fc215aa28570ca750afb7153f38d7fb62f92d28e404bb84396e2a90768", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_engine.py": "4b2ed4bb244a4b7537432e33706caf2abe19e44ab50cbc0a78db135e9581dee1", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_plan.py": "f8fff468b77753aa5f0d446c5d4381653659253051c1fcd066cd3b345cffd7c1", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__fft_word_sources.py": "46f40da411e3779b407bb11a0f7f1526b2d8611c1c6c1ab54f12f0cc00f8ebc2", + "evidence/real-hermitian-closure-20261023/sources/word__research__physical-fft-word__verify.py": "4be006b13288fd2bc7283aa34b231538917b34d0853f13e7d69558940685be92", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT1-BOUNDED-LEAF-RESULT.json": "1aa9573dd035660e745de17ecc50ef9b64c891ac8a6d7a8d380381fdc8268d6d", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT1-BOUNDED-LEAF.log": "fd3cc57c3a9b422481901154bbc1f3c9acc90eddbb7a3b54ee3d7b55c2715906", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT1-run_bounded_leaf.py": "0586aea518be3a3b4b96415095f864c67d128e8bfc6c9435189aceea9fba3f85", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT2-BOUNDED-LEAF-RESULT.json": "31448750858603b7299e8be6955971ed457505d2c4d7c509566d9f9d011076e4", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT2-BOUNDED-LEAF.log": "954a6bca0adac865fba01c6b9fee23f6512300ca984a306933aa5bf410db4448", + "evidence/real-packed-outer-consumer-20261023/ATTEMPT2-run_bounded_leaf.py": "6483f4e390be83a8cd9c92c016ade4f536a428e07e524ea04eafeb5951c0f8a4", + "evidence/real-packed-outer-consumer-20261023/BOUNDED-LEAF-RESULT.json": "31448750858603b7299e8be6955971ed457505d2c4d7c509566d9f9d011076e4", + "evidence/real-packed-outer-consumer-20261023/BOUNDED-LEAF.log": "954a6bca0adac865fba01c6b9fee23f6512300ca984a306933aa5bf410db4448", + "evidence/real-packed-outer-consumer-20261023/CONTRACT.md": "8caade86dfd81b5c4676eec3aedeffdf1e11fc59b370996c6245bfaa3f885f8d", + "evidence/real-packed-outer-consumer-20261023/EXECUTION-REPORT.md": "503a2a23db5409299464db4951ff0c961daa802bf37dea472a085022b766b389", + "evidence/real-packed-outer-consumer-20261023/FIXTURE-PLAN.md": "5bc9d4b45d6c906f9a24796705c6669f0b2e741654433f8f8c8b7ad7e9f714e5", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-FREEZE.json": "96722b6ef2652d50ae2e1590546f5fdc7cef34024003fe3a4e69f629e352369c", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-HARNESS-DIFF.patch": "46d42751a84c985f500982317cd23210e908462bee6704831fc482a9377211be", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-LAUNCH.json": "5e4e4f185daed7d9512da30109b82d5b605a32efa043202e958b0136886f186e", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-PLAN-ADDENDUM.md": "ed2f28f4536e40c044c5af32248db86472f3e9ca082ef05dc158e5d1984dffd1", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-REPORT.md": "18af0487a87b1c21d18573c2a957a25d60dc7c4d52b0f5254f07171e06807728", + "evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-STATIC-FREEZE.json": "28ef9aee512625a510214c44056dd098aeabb5d4b20af34ece7b2c6288d46c55", + "evidence/real-packed-outer-consumer-20261023/FULL-CALLER-PLAN.md": "e7cbd0cc8e3d129f023a847ec7de097edc72459cc452dafdd92246ed96496e07", + "evidence/real-packed-outer-consumer-20261023/FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json": "daa909a832d5b494716273cc2fefbdb525ddf3865d1c61a4877c8725f9dacfbf", + "evidence/real-packed-outer-consumer-20261023/FULL-PACKED-ATTEMPT2-RESULT.json": "01e85556753356dbcced9a43116b67cb6d9ea34126f5ef987821f23c06aab2b8", + "evidence/real-packed-outer-consumer-20261023/FULL-PACKED-ATTEMPT2.log": "0092b0e2fcd39723631273fe9b97bbeff11215ab12d21a5701f96bae708e8322", + "evidence/real-packed-outer-consumer-20261023/FULL-PACKED-RESULT.json": "50187fdd957a3efc04ab0fedb165877bf6e84bb5dfd85e2245dcebed3564ef7d", + "evidence/real-packed-outer-consumer-20261023/FULL-PACKED.log": "02e79d35a8f6e63f9c44c61e459ff61db068701589b60d8fb6fe8291eb9b38ef", + "evidence/real-packed-outer-consumer-20261023/FULL-PLAN-FREEZE.json": "05f2eaab810898aeccdb3ae31ef9638ccc529d2f9a85f1f6fe27303fdbad51d3", + "evidence/real-packed-outer-consumer-20261023/FULL-RUN-FREEZE.json": "30d57f24dd58976612713534bf86ad3a18412eae35cbfad4388f2bf85111e522", + "evidence/real-packed-outer-consumer-20261023/FULL-RUN-LAUNCH.json": "3bf161823deebfc12dea8a6bec193cb3b235d3029f03680847a038a5e6146fa2", + "evidence/real-packed-outer-consumer-20261023/FULL-RUN-REPORT.md": "284680cc59ca20d97d6410fd0a777d58c4bddd2884627d1ef2794073fde0f2d7", + "evidence/real-packed-outer-consumer-20261023/HARNESS-REPAIR.json": "5233755df1854d8d91e2fadd89b8341221a8022e811de02d1359720c23e20dbb", + "evidence/real-packed-outer-consumer-20261023/HARNESS-REPAIR2.json": "11907efdb7d888a4553ca29632e67b7407dbc00113f5ac67353dda1238882d6f", + "evidence/real-packed-outer-consumer-20261023/MANIFEST.json": "917a8cef760a730838f77a4a6b21c32dbcc9c992c515230549629986c92469da", + "evidence/real-packed-outer-consumer-20261023/METHOD-LEAF-RESULT.json": "78d0d34cd050e7c5b0678c3a36bc84c01bb9ac9de980ce9ee794e0f6a12a4780", + "evidence/real-packed-outer-consumer-20261023/METHOD-LEAF.log": "3fffdf2ba6fb983f5975a453cf7cc142a8afa59592da239bcff18ffa01977d35", + "evidence/real-packed-outer-consumer-20261023/PUBLIC-FIXTURE-BLOB.json": "76e89ec027030e854ce1fcab1ae3fda9739a5650e039d62b04cbd9144a2e4daf", + "evidence/real-packed-outer-consumer-20261023/PUBLIC-TEXT-BLOBS.json": "84cbcf6fe48cb2694acec6e0aed0e352ece33a842d57b4d786d8f2d8a67c1144", + "evidence/real-packed-outer-consumer-20261023/PUBLIC-TEXT-MANIFEST.json": "7c11d4878af29bcab1fbaee51f5ff90c78b91165f045fdf7a77851c8df264071", + "evidence/real-packed-outer-consumer-20261023/SOURCE-DIFF.patch": "019c9f4d0af107cb09740750f05f38cf3c7865fc097633fb4be6686aea1b9fe1", + "evidence/real-packed-outer-consumer-20261023/SOURCE-STATUS-UPDATE.md": "4f15deaffcc4c52f70d4ca6e6ceb0d4c80135c332875e1b5c887c8fc1a5c93e6", + "evidence/real-packed-outer-consumer-20261023/SOURCE-sandwich.py": "1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325", + "evidence/real-packed-outer-consumer-20261023/SOURCES.json": "6fa8f0c7c3af0e5a1526bcfed819b9d3bdfdb029ec9941b9e4a202efa0ddd71d", + "evidence/real-packed-outer-consumer-20261023/STAGING.json": "a1c9207393ce3158b7f78c4029039cb1761b301f5c36df0eab9b51cf538c0f8b", + "evidence/real-packed-outer-consumer-20261023/STATIC-REVIEW.json": "2780313fb349a9ca980dc1323ec2bd7bad2fe798d775bc09f71e896759913ad4", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-CALLER-PLAN.md": "e7cbd0cc8e3d129f023a847ec7de097edc72459cc452dafdd92246ed96496e07", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-PACKED-RESULT.json": "50187fdd957a3efc04ab0fedb165877bf6e84bb5dfd85e2245dcebed3564ef7d", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-PACKED.log": "02e79d35a8f6e63f9c44c61e459ff61db068701589b60d8fb6fe8291eb9b38ef", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-PLAN-FREEZE.json": "05f2eaab810898aeccdb3ae31ef9638ccc529d2f9a85f1f6fe27303fdbad51d3", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-RUN-FREEZE.json": "30d57f24dd58976612713534bf86ad3a18412eae35cbfad4388f2bf85111e522", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-RUN-LAUNCH.json": "3bf161823deebfc12dea8a6bec193cb3b235d3029f03680847a038a5e6146fa2", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/FULL-RUN-REPORT.md": "284680cc59ca20d97d6410fd0a777d58c4bddd2884627d1ef2794073fde0f2d7", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/SHA256SUMS.json": "8373463b66071f3606d810d984f588f875e4d226d0c06b5044f15ecf85dad857", + "evidence/real-packed-outer-consumer-20261023/full-attempt1-frozen/run_full_packed_DRAFT.py": "5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671", + "evidence/real-packed-outer-consumer-20261023/packed_sandwich_DRAFT.py": "5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483", + "evidence/real-packed-outer-consumer-20261023/run_bounded_leaf.py": "ccb11557b9087f17f25b68a1d005b33f38d9669691e83c78eddfc583bd663481", + "evidence/real-packed-outer-consumer-20261023/run_full_packed_DRAFT.py": "5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671", + "evidence/real-packed-outer-consumer-20261023/run_full_packed_attempt2_DRAFT.py": "c7bb6a705f42469709995f7d8a4c29ab0c12764d744546508a443151ec0345dc", + "evidence/real-packed-outer-consumer-20261023/run_method_leaf.py": "e7447e7fcab3dc9b15ab45eba9f943b76f65b99b50ca691c95e2159584881e6d", + "evidence/real-packing-independent-review-20261023/DRAFT-REVIEW-MANIFEST.json": "140ed23bd26a5a56d7df0d90920b104316c5eec6512114ac20983d1fe356582f", + "evidence/real-packing-independent-review-20261023/DRAFT-REVIEW.md": "ad856390a8632e1084b31cb660523e99c16884eaff3188d5904170159959af96", + "evidence/real-packing-independent-review-20261023/FREEZE.json": "5cb210ee02af97f878fc863f060eb49aa4e6c6b7a26445042df60f62acfcb004", + "evidence/real-packing-independent-review-20261023/REVIEW.md": "6b4c95aee5c222a9168159e77a45b007a4a48c1e9d201de4258e0bdcce0326be", + "evidence/real-packing-independent-review-20261023/SCALAR-CHECK-RESULT-OPTIMIZED.json": "44e24ba7b3d9bd4f07bb818057351d23e4abaa16e78750b01761ea61e55953a4", + "evidence/real-packing-independent-review-20261023/SCALAR-CHECK-RESULT.json": "44e24ba7b3d9bd4f07bb818057351d23e4abaa16e78750b01761ea61e55953a4", + "evidence/real-packing-independent-review-20261023/SHA256SUMS": "33024563a8b17cb53bf4c8021bc033b967f802dfbc23c0ef52813d2e8c7b09d0", + "evidence/real-packing-independent-review-20261023/TEST-SPEC.md": "3adb41c3e44cd17e46222580ceef071dd188da145fd71156c4cc58bf026e6267", + "evidence/real-packing-independent-review-20261023/check_scalar_obligations.py": "1bd90908e25672c038885e023ba74b8fe35a48f5bd123fdfc4a83bdbaa738c90" +} diff --git a/research/real-packed-tensor-staged-caller/PACKAGE-PINS.json b/research/real-packed-tensor-staged-caller/PACKAGE-PINS.json new file mode 100644 index 0000000000..a1d5533425 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/PACKAGE-PINS.json @@ -0,0 +1,12 @@ +{ + "source_archive_sha256": "5b683359c99644635d088864cdf9427c9913f01f80af8ef9b387537512bbf77b", + "source_manifest_sha256": "d1accba0ce83ac82a14da3111e91ed52b4e3cdb16ff77eeba8a848f3f94cfaee", + "evidence_manifest_sha256": "4d94e4986bb7b4bff72ff0de4136d03908c36020cd427ca621f5cabed853c633", + "candidate_sha256": "5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483", + "source_head": "e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1", + "source_status_successor": "467445ad61472f25e8b4d6757f838aceecf4fdec", + "source_status_successor_delta": "README only, scientific code and inputs unchanged", + "production_recovery_admitted": false, + "saving_admitted": false, + "recursive_kappa_claim": false +} diff --git a/research/real-packed-tensor-staged-caller/README.md b/research/real-packed-tensor-staged-caller/README.md new file mode 100644 index 0000000000..f7906d00c1 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/README.md @@ -0,0 +1,53 @@ +# Two-real packed outer caller: finite staged conformance + +**The actual observed integer is 0, equal to the reduced staged reference 0; the true product is 43113955509404415, so observed minus true is −43113955509404415.** One actual caller completed **two Tensor calls and three CRT calls**, comparing all 35 records at each declared stage, in 781.405280 seconds. This is finite staged conformance, not accurate integer recovery, production admission, a total finite speedup, or recursive κ improvement. The zero opposite result makes dynamic recovery-normalization discrimination degenerate. + +## Construction and evidence + +The new construction is the unchanged [packed_sandwich_DRAFT.py](evidence/real-packed-outer-consumer-20261023/packed_sandwich_DRAFT.py), SHA256 `5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483`. It preserves the published caller's constructor, private ownership, ingress, child protocol, recovery, carry, admission and consume methods. Both independent real streams are represented once, packed as u+i v, transformed once, unmixed with paid coordinate negation J, multiplied using exact widened raw splits and one truncation, then passed through the original opposite transform and recovery. Three CRT conversions remain. + +For H=(a+ib)/2^p and JH=(c+id)/2^p, the exact raw split operands are (a+c,b−d) and (b+d,c−a), on the p+1 grid. Their product is truncated once by p+2 to return to the p grid. On this p48 fixture the operand width is 51 and truncation shift is 50. The source R frequency dilation commutes with J; both S factors and the original recovery scale remain. The [source-bound contract](evidence/real-packed-outer-consumer-20261023/CONTRACT.md), [mathematical guard](evidence/mathematical-guard/real-packing-5095-fit.md) and [independent guard review](evidence/real-packing-independent-review-20261023/REVIEW.md) state the conditional production premises separately. + +The independent input streams are `[255,0,3,17]` and `[1,254,0,9]`, b8/q4, source (5,7), target (8,8), p48/P80, `require_recovery=False`. Raising precision at fixed reduced geometry does not supply production admission. The [actual report](evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-REPORT.md), [receipt with actual arrays](evidence/real-packed-outer-consumer-20261023/FULL-PACKED-ATTEMPT2-RESULT.json), [checkpoint](evidence/real-packed-outer-consumer-20261023/FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json), log and [independent post-run review](evidence/packed-caller-independent-gate-20261023/POSTRUN-REVIEW.md) retain exact bytes and limits. The forward has 28 nonzero records, the product 35, and the opposite zero. No oracle value overwrote actual output. + +Normal closure, borrowed/metadata values and heads, idle child owners, empty parent leases, pending-output rejection, paid consume, and later default production rejection passed. A separate failure before the first original CRT numerical operation passed its declared parent cleanup. This is not arbitrary active-child failure coverage. The first full run remains a **580.390962-second FAIL**, including interrupted-child scratch-lease and marker-erasure cleanup exceptions. Earlier harness setup failures, source leaves and actual method-leaf receipts remain preserved, rather than promoted into whole-caller evidence. + +Finite counters are 2 transforms, 3 conversions, 2 J-axis passes, 35 split records, 140 signed split operations and 140 parent-declared real products. The contract separately derives 30200 J source-loop moves, 7000 writes and 70 width-86 recovery products. These do not price every metadata, packing, storage, reset/clear and Tape transition. The original source's three-Tensor count is construction context, **not a matched benchmark**; this package reran no baseline. Captures, reference evaluation and checkpoint I/O are experiment overhead. + +## Quick replay and optional long reproduction + +From repository root, the registered quick hook is: + +```sh +python3 -I -B -W error research/real-packed-tensor-staged-caller/verify.py +python3 scripts/research_package.py --package research/real-packed-tensor-staged-caller --check-only +python3 scripts/research_package.py --package research/real-packed-tensor-staged-caller +``` + +It authenticates the 83-file archived source cohort and frozen evidence, then runs the unchanged independent post-run host checker in a temporary byte-identical layout. It uses host integer arithmetic for CRT, exact packing, split product, recovery and carry checks. It checks source/return byte-drift rejection and wrong-J/wrong-shift discrimination. **It does not import the numerical cohort, instantiate owners, execute Tensor/CRT calls, prepare coefficients or freshen the physical receipt.** It is also runnable in a Git-free exported package. Normal and optimized verification must retain the same checks. + +For an explicit separate long reproduction, first materialize a NEW directory: + +```sh +python3 -I -B -W error research/real-packed-tensor-staged-caller/materialize_reproduction.py /tmp/packed-staged-NEW +cd /tmp/packed-staged-NEW +(set -C; env -i PATH=/usr/bin:/bin LANG=C.UTF-8 /usr/bin/timeout -k 10s 900s /usr/bin/python3 -I -B -W error run_full_packed_attempt2_DRAFT.py > FULL-PACKED-ATTEMPT2.log 2>&1) +``` + +This executes the exact frozen actual harness with internal 880-second alarm, external 900-second cap and 30-second heartbeats, the same diagnostic fixture and no catalogue producer. Never overwrite existing result/checkpoint/tmp/log paths, vary the fixture, extend the budget or automatically retry. The optional command is **not registered in quick CI and was not rerun for packaging**. The existing successful receipt came from Python3.12/Linux; runtime portability is not promised. The prior 600-second Linux source timeout and later 452.68-second Linux source success are retained as historical source context, not matched candidate timing. + +## Source-bound ceiling and remaining scope + +The retained [real/Hermitian source closure report](evidence/real-hermitian-closure-20261023/REPORT.md) follows actual Tensor→Core→Interior/BandedSolve→FftWord lineage. That Core already executes real and imaginary scalar passes. Merely pairing two independent real channels scales both reward and paid work together, so this source-bound normalized moment does not improve. Independently dirty helper states need their full inventory served or lose independent reward. This is a ceiling on the inspected source contract, not a universal impossibility theorem. The rational-unitary RawGaussian/Gaussian/Full reference chain is not a runtime-child adapter here. No new literature search was used for packaging. + +The four complete-caller numerical mutations (wrong opposite sign, inverse R, missing S, double gamma) remain unrun. Earlier method-leaf controls have their narrower supplied-bank scope. This package establishes no all-input or all-size theorem, production recovery guard satisfaction, total priced profit, selected supplier, compiler reserve or κ change. Current canonical base is a5df48c55ea806d7952b65acc9c76d878ff09b13; bounded monitor coverage found no competing finite packed caller through its reported 11:12:56/cursor5156 intake, not exhaustive novelty. + +## Open next questions + +The structured [TASK.json](TASK.json) retains three bounded questions: bind a production-admissible nonzero recovery cohort; price the complete finite wrapper against a matched admitted baseline; and repair active-child interruption cleanup in a separate source change. Each states its relevance, first step and blocker. No further numerical fixture is proposed by this submission. + +## Sources, licensing and credit + +Primary source is [JoyboyBrian's PR5095 caller at e65f47db](https://github.com/CrocSwap/integer-mult-bounds/tree/e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1/research/physical-tensor-crt-sandwich-recovery). Successor467445ad changes only README; scientific bytes are unchanged. Tensor derives from [Jose Manuel / jmbarrancoml's PR3935 at f687fa17](https://github.com/CrocSwap/integer-mult-bounds/tree/f687fa171ef760fa98a4be1289717b47dd4ee0b3/research/physical-gaussian-tensor); CRT derives from Tekalign / tekuuu's PR4024 at e99297be; Mason Hale's prior dense rigorous recovery is credited by the source and not duplicated. Nested source manifests preserve the native, word, ring, routing and predecessor authors. + +[Inputs](inputs/SOURCE-COHORT.json) preserve all 83 consumed public files, including their LICENSE/NOTICE and authenticated nested archives, without editing predecessor packages. [SOURCES.json](SOURCES.json) pins base history and primary source links; [PACKAGE-PINS.json](PACKAGE-PINS.json) and [EVIDENCE-SHA256.json](EVIDENCE-SHA256.json) pin the retained bytes. New construction, packaging and checks are Apache-2.0 with substantial OpenAI Codex assistance. Source-specific original licenses/notices remain authoritative. The reviews are separate agent reviews, not independent human or formal-kernel acceptance. diff --git a/research/real-packed-tensor-staged-caller/SOURCES.json b/research/real-packed-tensor-staged-caller/SOURCES.json new file mode 100644 index 0000000000..1f273124a7 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ], + "retained_source_cohort": { + "path": "inputs/pr5095-consumed-source.tar.gz", + "sha256": "5b683359c99644635d088864cdf9427c9913f01f80af8ef9b387537512bbf77b", + "manifest": "inputs/SOURCE-COHORT.json", + "file_count": 83, + "origin": "Exact consumed PR5095 e65 public source/input cohort; nested source licenses and notices preserved.", + "primary_git_urls": [ + "https://github.com/CrocSwap/integer-mult-bounds/tree/e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1/research/physical-tensor-crt-sandwich-recovery", + "https://github.com/CrocSwap/integer-mult-bounds/tree/f687fa171ef760fa98a4be1289717b47dd4ee0b3/research/physical-gaussian-tensor", + "https://github.com/CrocSwap/integer-mult-bounds/tree/e99297be6749518a1b5b85cd129ecaf204d26c63/research/crt-address-streams" + ] + } +} diff --git a/research/real-packed-tensor-staged-caller/TASK.json b/research/real-packed-tensor-staged-caller/TASK.json new file mode 100644 index 0000000000..4b98dd221f --- /dev/null +++ b/research/real-packed-tensor-staged-caller/TASK.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 7, + "base_commit": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test.", + "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision", + "4100", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Construct one two-real packed outer caller and preserve one actual two-Tensor reduced staged conformance receipt, plus quick independent host evidence replay.", + "scope_change_reason": "Explicit donor assignment: a finite construction side result on the actual PR5095 caller, rather than a complete all-size uniform transfer proof.", + "bottleneck_link": "Finite physical caller wiring is a prerequisite check; reduced conformance does not close production or recursive transfer.", + "budget_minutes": 60, + "stop_rule": "One frozen reduced fixture; no further numeric replay, no production/total-saving/kappa admission.", + "outcome": "completed", + "evidence": "README.md and evidence/real-packed-outer-consumer-20261023/FULL-ATTEMPT2-REPORT.md", + "author": "CrocSwap research contributors with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in construction, static review, host arithmetic review, packaging and checks.", + "open_questions": [ + { + "question": "Can a production-admissible source cohort deliver nonzero accurate recovery under the same exact packed caller?", + "why_it_matters": "The current reduced opposite is zero and the output differs from the true product.", + "first_step": "Bind admitted geometry, coefficient precision and native premises before proposing a new bounded fixture.", + "blocked_by": "Source production parameter and full preparation-cost admission remain open." + }, + { + "question": "Does the complete physical tariff favor this outer wrapper?", + "why_it_matters": "Two Tensor calls alone do not price packing, J, split, storage and cleanup or imply a matched speedup.", + "first_step": "Price every added finite operation against one matched admitted baseline without changing the fixture implicitly.", + "blocked_by": "No complete priced tariff or matched baseline is claimed." + }, + { + "question": "Can active-child deadline cleanup be made complete?", + "why_it_matters": "The first full attempt exposed scratch-lease and marker cleanup exceptions.", + "first_step": "Review the inherited active-child ownership on the recorded timeout cut in a separately scoped source repair.", + "blocked_by": "This package preserves source and candidate bytes and does not repair interruption cleanup." + } + ] +} diff --git a/research/real-packed-tensor-staged-caller/VERIFY.json b/research/real-packed-tensor-staged-caller/VERIFY.json new file mode 100644 index 0000000000..6d71a4cda3 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/VERIFY.json @@ -0,0 +1,21 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Host-only frozen actual35-record chain, exact83-file source cohort, independent CRT/packing/product/recovery/carry arithmetic, lifecycle evidence binding and source/return/J/shift negative controls. No fresh numerical execution." + } + ] +} diff --git a/research/real-packed-tensor-staged-caller/evidence/canonical-guidance-check-1043.json b/research/real-packed-tensor-staged-caller/evidence/canonical-guidance-check-1043.json new file mode 100644 index 0000000000..d2e3fc30dc --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/canonical-guidance-check-1043.json @@ -0,0 +1,97 @@ +{ + "at": "2026-10-23 10:42:42 UTC", + "head": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "base": "20a1e31bc6009b9b3f4d084bbaadc6350e34fcba", + "checks": [ + { + "status": "fulfilled", + "value": { + "path": "AGENTS.md", + "sha": "aea5573d1b65cef7d9e08ced46d869e75da8145b", + "expected": "aea5573d1b65cef7d9e08ced46d869e75da8145b", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "CONTRIBUTING.md", + "sha": "fe54f23f19b082a9f8df3da9b2e205f7e230acf3", + "expected": "fe54f23f19b082a9f8df3da9b2e205f7e230acf3", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "autoresearch.md", + "sha": "2fe84a7b30b1e26e60ce0ec4775894eb1831c5d6", + "expected": "2fe84a7b30b1e26e60ce0ec4775894eb1831c5d6", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "docs/research/coordination.md", + "sha": "96db59be318181939d1e02b54ebba626b997d787", + "expected": "96db59be318181939d1e02b54ebba626b997d787", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "docs/research/agent-procedure.md", + "sha": "27d7029ef3840b96db1654d2448b6e7b49a8ce52", + "expected": "27d7029ef3840b96db1654d2448b6e7b49a8ce52", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "docs/research/current-priorities.md", + "sha": "a87818dafbca574053504ab07ceb7dd5eb805f77", + "expected": "a87818dafbca574053504ab07ceb7dd5eb805f77", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "docs/research/research-family-status.md", + "sha": "743a1afcbc46c715d2035037797e2f81b32e58a5", + "expected": "743a1afcbc46c715d2035037797e2f81b32e58a5", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "docs/research/agent-task-catalog.json", + "sha": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "expected": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "unchanged": true, + "error": false + } + }, + { + "status": "fulfilled", + "value": { + "path": "certificates/selected-result.json", + "sha": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "expected": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "unchanged": true, + "error": false + } + } + ] +} diff --git a/research/real-packed-tensor-staged-caller/evidence/mathematical-guard/real-packing-5095-fit.md b/research/real-packed-tensor-staged-caller/evidence/mathematical-guard/real-packing-5095-fit.md new file mode 100644 index 0000000000..e653699cc8 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/mathematical-guard/real-packing-5095-fit.md @@ -0,0 +1,90 @@ +# Two real inputs in one complete Tensor: exact PR5095 fit + +Prepared 2026-10-23 with substantial OpenAI Codex assistance. This is a source-bound proposal and error derivation, not an executed implementation, physical cost certificate, recursive closure theorem or selected-exponent improvement. Root coordinates any subsequent independent check. No code under the source repository was changed. + +## Published identity and its evidence class + +Robert Matusiak, *Implementing Fast Fourier Transform Algorithms of Real-Valued Sequences With the TMS320 DSP Platform*, Texas Instruments application report SPRA291, August 2001, Section 3.1 pp.5–6 and Appendix A.1 pp.18–19, gives the exact two-real-input packing and recovery formulas. Equation (22) is on printed p.18; that page was rendered and visually inspected. This is a primary published engineering report, **not a peer-reviewed mathematics paper**. Official source: . Local PDF SHA256: `aae9288bbf9e4c933f542ec4589b9de22cd591024c3947471893d0ec3995cfd8`. + +Steven G. Johnson and Matteo Frigo, *Implementing FFTs in Practice*, chapter 11 in C. S. Burrus (ed.), *Fast Fourier Transforms*, Rice University/Connexions, 2008, Eq.(7), printed p.17, records the underlying complex linearity for two real arrays. Its SIMD application is a different implementation direction, so no native cost result is imported. Author-hosted source: , SHA256 `454dc303d65ee0279042e815d390abaa2ef59147cba115ee1fdfa5561a18ad9a`. + +IBM's author record verifies the related Cooley–Lewis–Welch 1970 *Journal of Sound and Vibration* paper, DOI `10.1016/0022-460X(70)90075-1`. Its primary full text was not obtained; no equation or first-discovery attribution is inferred from its metadata. This proposal is standard FFT prior art with a possible new local contract binding. + +## Authenticated actual source + +JoyboyBrian's PR5095 head is `e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1`. The separate source worker froze `outputs/outer-bilinear-interface-20261023/APPENDIX-5095.md`, SHA256 `87243c00536e42cbc8663b645b80c83a4cf3a8558a9442d37855c6de38b75a69`, and `APPENDIX-5095-SOURCES.json`, SHA256 `a41239e2bca82f6f8fb63f79eebc11f40bd7cb3671cee30ce94d7ef217315d76`. All nine listed snapshots were hash-checked here. This worker read the appendix, literal ingress/product/recovery code, the complete Tensor proof and the source07 transform/permutation definitions. No nested dependency archive was executed. + +The existing entry sends two independent borrowed radix digit streams through ingress and CRT, then **two separate complete forward Tensor calls**, scalar pointwise multiplication, one complete opposite Tensor call, exact rescaling, inverse CRT and carries. The actual nonlinear cut is scalar multiplication on `C^S`, distinct from the inner polynomial-record product `uv/r` in `(C[y]/(y^r+1))^M`. + +Relevant source locators: + +- `research/physical-tensor-crt-sandwich-recovery/sandwich.py:53–88,175–188`: quarter-disk ingress, literal product, recovery and call order. +- Its `PROOF.md:86–122`: conditional production approximation and strict recovery guard. +- `research/physical-gaussian-tensor/PROOF.md:25–52,151–160`: complete returned orientation, restoration gamma and error. +- `upstream/build/sections/07-resampling.tex:13–16,60–62,311–322,461–485` in the prior frozen source map: normalized transforms, frequency dilation and convolution normalization. + +For source shape `(s_1,...,s_D)` let `S=product s_i`. The complete ideal forward map is + + T = R F^-_s, (R z)_j = z_(t_1 j_1,...,t_D j_D), + (F^-_s u)_k = (1/S) sum_j u_j exp(-2 pi i sum_i j_i k_i/s_i). + +The complete opposite map is `Tplus=R F^+_s`. The source has `gcd(t_i,s_i)=1`. Both maps are contractions in coordinate sup norm. The restored Tensor exponent is `gamma=D(2 alpha^2+ceil(log2(32p))+1)` with the actual source parameters; it is not an extra factor in these already completed ideal endpoints. + +## Exact proposed replacement + +After the same CRT conversion, let `u,v` denote the two real arrays. Each component is a nonnegative digit divided by `2^(b+2)`, so `0<=u_j,v_j<1/4`. Their packed array + + h = u + i v + +has modulus strictly below `sqrt(2)/4<1/2`, inside the existing arbitrary-half-disk Tensor ABI. Ingress is exact on the p-grid because the source requires `p>=b+2`. + +Let `J` negate each source coordinate modulo its own `s_i`, and write `H# = conjugate(J H)`. Frequency dilation R commutes with J, so the usual real-input identity survives the actual retained permutation. With `H=T h`, define + + A = (H+H#)/2 = T u, + B = (H-H#)/(2i) = T v, + Z = A*B = (H^2-(H#)^2)/(4i). + +Here products and squares are scalar coordinatewise operations. The same completed opposite call gives + + Tplus(Z) = (u*v)/S^2. + +The existing recovery multiplier `S^2 * 2^(2b+4)` is therefore unchanged. The CRT digit embedding and inverse CRT are unchanged mathematical maps. This is an exact replacement of the two initial complete forward calls by one complete forward call and an explicit splitting/product operation. It is not a proposal to run the real and imaginary parts independently through a rounded Tensor: the actual packed complex call must be used, and rounded Tensor linearity is never assumed. + +## A sufficient error lemma using the existing strict guard + +This paragraph is a new elementary source-bound deduction, not a theorem attributed to the FFT report. Retain all source production-page and complete-Tensor approximation premises. Put + + hgrid = 2^-p, + E = D*p^2 + 6*M + 22 + 2*D, + epsilon = E * 2^gamma * hgrid, + C = S^2 * 2^(2b+4). + +The existing guard `(G)` is exactly `C(3 epsilon+2 hgrid)<1/2`. Source `b>=1` and `S>=1` imply `C>=64`, hence `epsilon<1/384`. + +Suppose the one packed complete call returns `Htilde` with `||Htilde-H||` launch is not a general log non-overwrite guard. No automatic retry is present. + +## Deadline, budget and remaining lifecycle boundary + +The proposal changes the external cap from 600 to 900 seconds and the internal alarm from 580 to 880 seconds, preserving the 30-second heartbeat. It records `deadline_triggered` and elapsed time before raising, so an inherited cleanup exception cannot erase the deadline's provenance from R. Source/candidate/harness drift still forces a nonzero failure. + +The larger cap is a bounded new proposal motivated by the observed incomplete run: the first forward finished between the 360- and 390-second heartbeats, and the opposite was still executing when the deadline fired. This supports reconsidering the earlier insufficient envelope; it does not prove 900 seconds sufficient. No adaptive fixture, retry, producer preparation or source-baseline replay is added. Root retains the explicit decision on this one proposed larger attempt. + +**Inherited deadline/numerical-child cleanup is not repaired.** The first timeout occurred inside an active numerical child and its cleanup failed. Neither the static source preservation nor durable checkpoints validate interruption cleanup, complete opposite execution, recovery, borrowed/private restoration after a completed full call, or the later injected first-dispatch failure control. Those remain distinct runtime outcomes. A second failure must retain its nonzero result, deadline flag, checkpoint and full exception chain. + +The same scope limits remain: `require_recovery=False` is reduced staged conformance; four full-stage mutation controls remain unrun; no production Fourier accuracy, total cost saving, recursive closure, compiler reserve or κ improvement follows from a checkpoint or a future finite pass. + +## Verification + +`python3 -B outputs/packed-caller-independent-gate-20261023/check_attempt2_static.py` passed, producing `ATTEMPT2-STATIC-RESULT.json` with `PASS_MINIMAL_ATTEMPT2_STATIC_DURABILITY_GATE`. Checks cover exact diff, eight original/backup pairs, all original scientific input hashes, unchanged selected AST calls, observer-only checkpoint additions, source/candidate pins and fresh new evidence paths. Only standard-library static analysis ran. No numerical process or test was launched. + +Credit remains with the source/draft/fixture authors, the constructor's observation repair, prior independent reviewers and retained Tensor/CRT/native/word/recovery contributors. Prepared with substantial OpenAI Codex assistance; no independent human or formal-kernel acceptance claimed. diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/ATTEMPT2-STATIC-RESULT.json b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/ATTEMPT2-STATIC-RESULT.json new file mode 100644 index 0000000000..ca37878f6a --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/ATTEMPT2-STATIC-RESULT.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_MINIMAL_ATTEMPT2_STATIC_DURABILITY_GATE", + "no_numeric_execution": true, + "new_harness_sha256": "c7bb6a705f42469709995f7d8a4c29ab0c12764d744546508a443151ec0345dc", + "prior_harness_sha256": "5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671", + "addendum_sha256": "ed2f28f4536e40c044c5af32248db86472f3e9ca082ef05dc158e5d1984dffd1", + "exact_diff_sha256": "46d42751a84c985f500982317cd23210e908462bee6704831fc482a9377211be", + "prior_receipt_sha256": "50187fdd957a3efc04ab0fedb165877bf6e84bb5dfd85e2245dcebed3564ef7d", + "prior_backup_files_verified": 8, + "all_original_source_input_hashes_preserved": true, + "scientific_and_ownership_call_ASTs_unchanged": true, + "observer_changes_only_post_match_checkpoint": true, + "fresh_attempt2_evidence_paths": true, + "proposed_external_cap": 900, + "proposed_internal_alarm": 880, + "durability_scope": "Matched completed-stage records, atomic whole-file replacement and process-failure retention; no whole-caller-success or power-loss persistence claim.", + "remaining_limits": [ + "No observed opposite/recovery/postconditions from attempt1", + "Inherited deadline/numerical-child cleanup not repaired", + "Four full-stage mutants remain unrun", + "require_recovery=False remains diagnostic", + "No execution authorized by this reviewer" + ] +} diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-CHECK-RESULT.json b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-CHECK-RESULT.json new file mode 100644 index 0000000000..9aa987bfc8 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-CHECK-RESULT.json @@ -0,0 +1,51 @@ +{ + "status": "PASS_INDEPENDENT_POSTRUN_STAGED_EVIDENCE_REVIEW", + "no_numeric_replay_or_cohort_import": true, + "observed_integer": 0, + "staged_integer": 0, + "true_integer": 43113955509404415, + "observed_minus_true": -43113955509404415, + "accurate_integer_recovery_claim": false, + "receipt_sha256": "01e85556753356dbcced9a43116b67cb6d9ea34126f5ef987821f23c06aab2b8", + "checkpoint_sha256": "daa909a832d5b494716273cc2fefbdb525ddf3865d1c61a4877c8725f9dacfbf", + "completed_Tensor_returns": 2, + "completed_CRT_returns": 3, + "records_each": 35, + "signed_component_bits": 50, + "inverse_CRT_record_bits": 86, + "output_bits": 64, + "raw_return_lengths": [ + 3500, + 3500, + 3500, + 3500, + 3010 + ], + "raw_return_hashes": [ + "c8ca6eefe2d864683cdcf5257e1485830b1a3ebaea7ec31733704822efb74b86", + "35b2040a56c60e04e883349c5f2fd0edc0a8530b798eb9d29268d14ee5a0fc4f", + "e8018d05dbcd3a56e294986f321ab5ad3bf394dca054077ce4a3928354d3c8bf", + "94f9f38c22dbf4b8b02faf2d07b4a6c2366bf32a0ff14d3b46ff281c2d6665e6", + "bb5cb6199f244df19a4bd2a36c31d8b733ad3ee0837ed887bee09326ddc0b0e9" + ], + "independent_physical_product_sha256": "8697b1e5d265b236653847496b582ca5138709522dca434bf83b51a5c4b69382", + "source_and_candidate_current_hashes_checked": 84, + "nonzero_records": { + "forward": 28, + "product": 35, + "opposite": 0 + }, + "product_max_squared_norm_numerator": 134891816039001096192, + "squared_norm_denominator": 79228162514264337593543950336, + "normal_lifecycle_flags_and_exact_harness_assertions_verified": true, + "failure_cut": "pre-firstConverter dispatch only; earlier deadline numerical-child cleanup failure remains", + "seconds_reported": 781.40528, + "all_prior_failure_artifacts_preserved": true, + "limits": [ + "No production accuracy/admission", + "Zero opposite makes recovery normalization check degenerate", + "Four full-stage mutations unrun", + "No full priced tariff or matched speedup", + "No recursive moment/compiler reserve/kappa claim" + ] +} diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-REVIEW.md b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-REVIEW.md new file mode 100644 index 0000000000..2532c1c37b --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/POSTRUN-REVIEW.md @@ -0,0 +1,63 @@ +# Independent postrun review: completed reduced packed caller + +**PASS for the recorded finite staged endpoint and declared lifecycle controls. The observed integer is 0; the true product is 43113955509404415; observed minus true is −43113955509404415.** The 64 returned zero bits match the reduced staged reference. They do not recover the true product, establish production accuracy or support an integer-multiplication claim. + +The constructor's single authorized replacement completed in **781.405280 seconds** with two complete Tensor calls and three complete CRT calls. This review did not rerun that process, import the numerical cohort, construct an owner or execute an operator. `check_postrun.py` performs only JSON/hash checks and independent host-integer calculations over captured actual arrays; it completed in about 0.21 seconds. Its status is `PASS_INDEPENDENT_POSTRUN_STAGED_EVIDENCE_REVIEW` in `POSTRUN-CHECK-RESULT.json`. + +## Exact evidence binding and preservation + +| Evidence | SHA256 | +|---|---| +| FULL-PACKED-ATTEMPT2-RESULT.json | `01e85556753356dbcced9a43116b67cb6d9ea34126f5ef987821f23c06aab2b8` | +| FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json | `daa909a832d5b494716273cc2fefbdb525ddf3865d1c61a4877c8725f9dacfbf` | +| FULL-PACKED-ATTEMPT2.log | `0092b0e2fcd39723631273fe9b97bbeff11215ab12d21a5701f96bae708e8322` | +| FULL-ATTEMPT2-REPORT.md | `18af0487a87b1c21d18573c2a957a25d60dc7c4d52b0f5254f07171e06807728` | +| Executed run_full_packed_attempt2_DRAFT.py | `c7bb6a705f42469709995f7d8a4c29ab0c12764d744546508a443151ec0345dc` | +| Candidate packed_sandwich_DRAFT.py | `5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483` | + +All entries in the author's FULL-ATTEMPT2-FREEZE.json match current bytes. The receipt's before/after maps are equal, and this review independently rehashed every listed current file: **83 staged source files plus the candidate**, 84 entries total. The executed harness also matches its reviewed hash. The cached packet remains the pinned p48 (5,7) source asset; no new coefficient preparation or source/operator modification appears in this evidence. + +All eight first-attempt original artifacts and their frozen copies retain their recorded hashes. That attempt remains the **580.390962-second deadline-triggered FAIL**, including inherited scratch-lease and marker-erasure cleanup errors. This normal-return success neither repairs that interruption failure nor converts its missing observations into retained data. Prior static/optimistic-budget artifacts were left unchanged. + +## Durable actual records and independent arithmetic + +The completed-child checkpoint and final receipt have exactly equal Tensor/CRT observation lists and actual product bits. Each actual child return contains a valid bit array of the prescribed full length; its independently recomputed SHA256 matches the stored return hash. The five child returns have lengths **3500, 3500, 3500, 3500 and 3010 bits**: 35 complex records with two 50-bit components for both Tensors and both forward CRTs, then 35 signed 86-bit records for inverse CRT. Both captured forward-CRT inputs and the inverse-CRT input also have matching hashes and exact lengths. The two forward/opposite completion messages appear once each in the log, consistent with two completed durable Tensor returns rather than merely two dispatches. + +The signed codec was checked from the authenticated nested source as data: `ring_check_words.word_bits` emits low bit first, and `ring_words.read_signed`/`write_signed` use width-bit two's complement. These were read through the frozen expansion→core→word→ring archive chain, not imported. The host checker independently decodes/encodes that format. + +1. From the captured actual forward-CRT inputs, it reconstructs exact p48 ingress for the two independent b8/q4 streams `[255,0,3,17]` and `[1,254,0,9]`, padded to 35 records. It independently applies the source CRT map `k -> (k mod5,3k mod7)` and checks all actual returned records, including zero imaginary parts. +2. It packs the two **actual** CRT returns as u+i v, checks the actual forward Tensor input hash, and verifies its strict half-disk bound. The captured forward H contains 28 nonzero complex records and matches all 35 frozen staged-reference records. +3. It computes JH from that actual H by `(-i mod5,-j mod7)`. For each actual pair H=(a,b), JH=(c,d), it independently uses the four split operands `(a+c,b-d,b+d,c-a)`, verifies signed 51-bit headroom, forms the exact complex product, and truncates once toward zero by **50 bits**. This reproduces every actual product record and the product SHA256 `8697b1e5d265b236653847496b582ca5138709522dca434bf83b51a5c4b69382`. Its algebra is independently checked against the author's squared-difference formula. All 35 product records are nonzero. +4. It verifies that the actual opposite Tensor input hash equals this actual product, and checks its half-disk bound using exact integers. The maximum squared-norm numerator is `134891816039001096192` on denominator `2^96`, well below 1/4. The actual opposite return is **35 complex zeros**, matching all frozen staged-reference records. +5. From that captured actual opposite return, it independently applies S², shift 2b+4=20, nearest p48 rounding, inverse CRT and the 64-bit carry output. All 35 recovered/inverse-CRT coefficients and all 64 output bits are zero. Reconstructing the true radix operands separately gives 43113955509404415, preserving the exact mismatch above. + +The actual J bank was compared record by record during the run by the reviewed observer. It is not separately retained as another raw physical bank in the receipt; the independently reconstructed J of captured H matches the recorded expected J, and the actual product is durably retained. This distinction does not create an additional captured-child claim. + +**The zero opposite is a material discrimination limitation.** This run executes the original recovery and carry code, but a zero input to recovery cannot dynamically distinguish missing S, doubled gamma or many orientation/sign changes. The source normalization identity and exact code path retain their prior static/mathematical support; this fixture supplies no new nonzero recovery-normalization test. The four whole-stage mutation controls remain explicitly unrun. No new model/Tensor replay was performed by this reviewer to extend that scope. + +## Lifecycle and finite bill + +The exact executed harness reaches PASS only after its assertions for successful normal closure, idle child owners, empty parent live pool, pending return, restoration of both payloads/catalogue and b/q metadata values/heads, end-head pending rejection, paid consume, post-consume production-policy rejection and resident empty origins. The corresponding receipt flags are true. This review verifies their binding to the unchanged executed harness; it does not inspect terminated in-memory Tape objects or claim new exhaustive dynamic coverage. + +The runtime preflight controls cover six metadata-to-payload aliases and five descendant-private aliases, plus the retained constructor rejection cases. Other port coincidences remain statically excluded by the preserved five-distinct-port predicate. The separate injected failure occurs **before the first original Converter numerical operation**, while the parent holds its first ingress bank. It adds one injected dispatch and zero numerical children, then verifies its declared parent/borrowed/metadata cleanup. It does not validate arbitrary exceptions inside an active numerical child or resolve the first attempt's deadline cleanup failure. + +Recorded counters are consistent with the fixed path: + +| Counter | Recorded value | +|---|---:| +| Complete Tensors / CRT conversions | 2 / 3 | +| Packed records / J axis passes | 35 / 2 | +| Product passes / split records | 1 / 35 | +| Split signed operations / parent-declared real products | 140 / 140 | +| Each Tensor: padding, gathers, halos | 4, 4, 4 | +| Each Tensor: expansion, compression, assembly axes, chirps | 2, 2, 2, 1 | +| Each CRT: global routes, triangular shifts, padding passes | 1, 2, 2 | +| Each CRT router: batches, edges, involutions, literal | 1, 3, 2, 1 | + +Parent counters are not a new independent meter of every nested physical primitive. The declared 30,200 J-loop source moves and 7,000 writes, and 70 width-86 recovery products, remain source-derived finite bills. They do not include every metadata, setup, storage, reset/clear and Tape transition. Checkpoint/fsync/reference/capture work is experiment overhead. There is no matched three-Tensor baseline here and no complete priced total saving certificate. The earlier method-leaf measurements retain their narrower supplied-bank scope. + +## Accepted scope + +The evidence supports **one physically executed two-complete-Tensor finite wrapper chain conforming to the reduced staged reference**, with its tested normal lifecycle and precisely declared pre-dispatch failure control. It preserves `require_recovery=False` and default production rejection. It does not recover the true integer product; establish ideal Fourier/production accuracy, all-input correctness or arbitrary interrupted-child cleanup; price a total finite profit; create a recursive Gaussian reward; or improve a compiler reserve, selected bound or κ. + +Root requested no additional heavy runs, and none were performed. Review command: `python3 -B outputs/packed-caller-independent-gate-20261023/check_postrun.py`. Original source/candidate/evidence and earlier review receipts were preserved. Credit remains with the source Tensor/CRT/native/word/recovery authors, the packed-caller constructor and prior mathematical/static reviewers. Review/checker prepared with substantial OpenAI Codex assistance; no independent human or formal-kernel acceptance claimed. diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/REVIEW.md b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/REVIEW.md new file mode 100644 index 0000000000..27d9c62254 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/REVIEW.md @@ -0,0 +1,65 @@ +# Independent static gate for the packed PR5095 whole caller + +Status: **static draft/source and whole-caller harness gate PASS for root's separate execution/budget decision.** No Tensor, CRT converter, native numerical code, owner constructor, factory or candidate method was imported or executed by this reviewer. `check_static.py` uses only AST parsing, JSON and byte hashes. Root retains the decision on numerical execution and its budget. This report does not authorize that execution. + +The source is PR5095 head `e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1`, frozen `SOURCE-sandwich.py` SHA256 `1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325`. The reviewed draft is `packed_sandwich_DRAFT.py`, SHA256 `5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483`. `STATIC-RESULT.json` records 82 manifest-file checks, exact staged source/draft/fixture hashes, unchanged-method comparisons and callsites. The cached p48 (5,7) packet hash is `7dd7adbe9e8f6d5ffbecd425a72827b31d7222ee51bcd67a4148ebfd03420381`; authenticating it does not repeat or execute its coefficient producer. + +## Actual path and inherited lifecycle + +The draft preserves the actual source cohort and the owner graph. It changes the source class name to `RealPackedSandwich`, retains every original import, and adds only `compact_counts.copy_bits`, `ring_words.add` and `ring_words.difference`. Constructor, consume, child, ingress, recover, carries, admit and the global `private_tapes` function are AST-identical. Both inner and outer `run` finally blocks, the literal recovery-policy default and the successful pending-return tail are also identical. + +The actual run path is: + +``` +ingress(first) -> actual CRT forward -> natural_first +ingress(second) -> actual CRT forward -> natural_second +pack_real -> actual packed Tensor forward -> H +paid coordinate negation -> JH -> widened split/product -> product +actual Tensor opposite=True -> recover -> actual CRT inverse -> carries +``` + +There are three actual CRT conversions and two actual Tensor calls. The constructor must instantiate the retained `Tensor(finite_chirp(),FullRouter(literal_native()))` and `Converter(FullRouter(literal_native()))` inside the authenticated `sandwich_sources.opened()` cohort. A separate leaf owner or model-only transform cannot establish this path. The reduced `p48_setup()` replacement is the source's certified metadata fixture; it must remain explicitly labelled and must not replace numerical child bodies. + +Five borrowed ports are required distinct: both operand tapes, catalogue, b tape and q tape. Every one is excluded from the full private graph, including descendant pools and word backing. The constructor transfers only fresh closed, lease-free, disjoint child owners. Its private-graph traversal also rejects nonclosed nested owners and checks empty resident data/origins. These source guards are preserved, not newly established by the earlier method leaf. + +Each child return is copied into a parent lease before its original is cleared and its marker retired. The source child methods retain their own consumed-return checks. The parent retains H while creating JH, clears consumed naturals/packed/product/returns only after their last read, and does not use helper fields as scratch or productive credit. `negate_frequencies()` clears an intermediate route bank only after its replacement is complete. For positive source dimension, reflected and H are distinct leases; the fixed fixture has dimension two. The new methods/run allocate no resident `Tape`. + +After success, all borrowed tapes/count heads are rewound, the catalogue closes, parent leases are cleared/emptied, resident pool markers are erased, and the output is rewound and marked pending. Reuse is rejected until `consume()` clears it and retires its marker, including when the output head has moved to the end. On a normal raised operation error, the same outer finally clears any remaining parent leases and unsuccessful output, restores heads and closed state; the successful pending assignment is skipped. Failures inside cleanup itself, arbitrary asynchronous interruption and untested nested-child failures are not automatically covered by this static observation. A dynamic receipt must identify the precise failure cut it exercises. + +## Arithmetic and recovery binding + +For b8/q4/p48, ingress requires `2q-1=7<=35`, `35<256`, and `48>=8+2`. The original two independent radix streams become exact real quarter-disk arrays, and the draft explicitly checks both converted imaginary components are zero. Packing their real components forms h=u+iv with norm below sqrt(2)/4<1/2. Neither operand is reconstructed from the other. The real-input zero check alone is not an admission for arbitrary externally supplied complex banks. + +J negates both original source coordinates modulo 5 and 7, preserving bits inside each record. It commutes with the source coordinate dilation R. For actual returned numerators `H=(a,b)`, `JH=(c,d)`, the draft's exact split raw numerators are `(a+c,b-d)` and `(b+d,c-a)` on grid p+1. Input words widen from p+2=50 to p+3=51 bits. Their exact product has grid 2p+2, so one final truncation by p+2=50 restores grid p. An independently expressed product numerator is `(2ab+2cd,-a²+b²+c²-d²)`; this is a suitable check against the physical four-product calculation. Shift p on the raw sums would introduce a factor-four error. + +The actual opposite call remains `opposite=True`; the source conjugates input and output and produces the same-R opposite transform, rather than R-inverse. Tensor gamma restoration remains inside its unchanged boundary method. The parent `recover()` still multiplies by S twice, scales by 2^(2b+4), and rounds nearest on the p-grid; for b8 the retained recovery input width is 50+4*8+4=86. Inverse CRT and carries are unchanged. No extra gamma or missing S is justified. + +`require_recovery=True` still calls the unchanged production-mode test and strict recovery guard before ingress. The p48 (5,7) catalogue is reduced staged conformance and must be rejected by this default entry. The planned full fixture must explicitly use `require_recovery=False`, and its actual opposite half-disk check must remain enabled. A returned diagnostic integer must be reported separately from the true integer product, including any discrepancy. Raising p at fixed (5,7) does not supply production geometry/halo premises. + +The independent mathematical review in `outputs/real-packing-independent-review-20261023/REVIEW.md` supplies a conditional unchanged-(G) error lemma under the source production-page and complete-Tensor hypotheses. This static gate does not re-prove or admit those hypotheses. The method leaf's PASS at 8.913140 seconds uses supplied p-grid banks and zero numerical Tensor/Converter calls; it establishes none of the complete-call, production or all-input claims by itself. + +## Frozen whole-caller harness review + +The reviewed `run_full_packed_DRAFT.py` has SHA256 `5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671`; `FULL-CALLER-PLAN.md` has SHA256 `e7cbd0cc8e3d129f023a847ec7de097edc72459cc452dafdd92246ed96496e07`. `FULL-PLAN-FREEZE.json` binds these, the unchanged candidate and cached fixture, and records `execution_authorized=false`, `executed=false`. This review read/parsed that exact harness without importing it. + +The harness constructs the actual retained Tensor/Converter owners and calls `RealPackedSandwich.run` on the fixed q4 pair `(255,0,3,17)` / `(1,254,0,9)`. Phase and dispatch guards allow numerical bodies only for that one declared invocation, capped at two Tensor and three Converter calls. The actual call uses `p48_setup(),no_decode()` and literal `require_recovery=False`. Default production entry is exercised and rejected before numerical work by candidate preflight controls and again after consume. + +Its separate natural-coordinate staged oracle computes `full(packed,raw)`, then the squared-difference product formula above, then `full(product,raw,True)`. It never substitutes separately rounded real forwards. Before numerical work, it requires nonzero forward/product, opposite half-disk entrance, nonnegative diagnostic coefficients and a result fitting the prescribed 64 bits; otherwise it stops without choosing another fixture. Every actual Tensor input and returned complex record is compared. JH and the actual pointwise output are compared before the second Tensor. Thus the model product used by the opposite oracle equals the actual once-truncated input if the preceding assertions pass. No model value is written into a numerical source return. + +Every CRT input and return is captured and compared. The two actual forward CRT inputs are checked against the independent exact ingress banks; the actual inverse CRT input is checked against all 35 widened recovered natural coefficients. All 35 ordinary coefficients after inverse CRT are also checked. Review raised the initially narrower return-only trace coverage, and the final frozen harness added these pre-delegation input checks and retained input bits/hashes without changing source or operator code. + +The harness snapshots borrowed payload/catalogue and b/q metadata bytes and exact heads; checks them after success and after its declared failure; checks actual child count dictionaries, parent counters, closed/lease-free states and resident empty origins; and tests an occupied end-head output rejection followed by real consume and production-policy re-entry. The original dynamic controls cover three constructor failures, six metadata/payload aliases and five descendant-private aliases, not every possible port coincidence. Preserved static predicates reject the remaining five-port coincidences. + +One explicit failure probe throws at the first Converter dispatch **before delegation**, when the parent owns its first ingress bank. It checks that parent's cleanup without another numerical call. It does not dynamically test failures inside a numerical child, after later Tensor completion, or arbitrary asynchronous interruption. + +Review found and the constructor corrected an observer ownership defect before this freeze: a successful original child return would previously remain occupied if the observer's post-delegation inspection raised before parent `child()` received it. Both observers now clear the return and retire its marker under `except BaseException`, returning the unchanged bank only on successful inspection. The harness also now records its own hash and forces a nonzero FAIL status on any source/candidate/harness drift; integrity failures cannot retain a PASS label. + +The explicit diagnostic result records staged and true integers, signed difference and equality flag. Four full-stage mutation controls (wrong opposite sign, inverse-R, missing S, double gamma) remain explicitly unrun. Correct flags and full staged-return comparisons are checked, but this report does not claim that those four mutated numerical callers were executed or independently shown discriminating on this fixture. Earlier supplied-bank method discriminators remain distinct evidence. + +The plan proposes one external 600-second cap, an internal 580-second alarm and 30-second heartbeat, with no producer preparation, original full replay, alternate input, retry or automatic budget increase. Its 300–500-second planning envelope is an estimate, not a verified runtime for this new input. The cited later 452.68-second source replay is coordinator/workflow evidence, not independently rechecked here. Logs, partial counts and timeout/failure receipts must remain visible if the run does not finish. Trace capture/reference work is observational overhead; this run would not establish a complete tape tariff or matched speedup benchmark. + +## What a successful finite full run would still leave open + +One successful reduced fixture would validate that instance's rounded two-Tensor schedule against its staged reference and tested lifecycle controls. It would not prove production Tensor accuracy, the production recovery premise, uniform all-input correctness, a complete Turing-machine tariff, total cost reduction, recursive real/Hermitian closure, a new supplier moment, compiler reserve, selected-frontier change or κ improvement. The removed Tensor call must still be compared against added packing, J routing, widened word products, metadata, storage, cleanup and setup at the actual paid interfaces. No helper/owned-field output reward is created by packing. + +Read-only static command: `python3 -B outputs/packed-caller-independent-gate-20261023/check_static.py`. Prior author and independent artifacts were preserved. Credit JoyboyBrian's PR5095 caller, Jose Manuel/jmbarrancoml's actual Tensor, Tekalign/tekuuu's CRT, retained native/router/word/recovery sources, real-FFT prior art, Astra's source-bound error deduction and the preceding independent reviewers. Prepared with substantial OpenAI Codex assistance; no human or formal-kernel acceptance claimed. diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/STATIC-RESULT.json b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/STATIC-RESULT.json new file mode 100644 index 0000000000..7869bcbb2b --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/STATIC-RESULT.json @@ -0,0 +1,474 @@ +{ + "status": "PASS_STATIC_DRAFT_AND_SOURCE_BINDING", + "no_numeric_execution": true, + "source_head": "e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1", + "source_sha256": "1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325", + "draft_sha256": "5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483", + "unchanged_methods": [ + "__init__", + "consume", + "child", + "ingress", + "recover", + "carries", + "admit" + ], + "private_owner_graph_unchanged": true, + "original_imports_retained": true, + "new_imports": [ + "compact_counts.copy_bits", + "ring_words.add", + "ring_words.difference" + ], + "outer_and_inner_run_finally_unchanged": true, + "literal_recovery_default_and_pending_return_tail_unchanged": true, + "new_methods_and_run_allocate_no_Tape": true, + "static_child_callsites": [ + { + "operation": "self.tensor.run", + "line": 247, + "options": {} + }, + { + "operation": "self.tensor.run", + "line": 252, + "options": { + "opposite": "True" + } + }, + { + "operation": "self.converter.run_plan", + "line": 255, + "options": { + "inverse": "True", + "record_bits": "width" + } + }, + { + "operation": "self.converter.run_plan", + "line": 243, + "options": {} + } + ], + "note": "Converter forward callsite lies in two-input loop: three total conversions. Two Tensor callsites total, latter opposite.", + "authenticated_inputs": [ + { + "path": "LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "binding": "PR5095 declared input" + }, + { + "path": "NOTICE", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/EXPECTED.json", + "sha256": "cd9cf52189f6fedb5cb09da7bb2af06acfe42ee370e0efc0293bca19dd897e08", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/NETWORK-SOURCES.json", + "sha256": "c843e86f64902c63cfbac72b7d743ae628abd430ba3987a0b8c6254de3b9b22b", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/PROOF.md", + "sha256": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/README.md", + "sha256": "2f179858402d1eac28b1da46139fa3198a625375532cc2c53a01c1ffc565281b", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/SOURCES.json", + "sha256": "96b3228ee210e10c9f6c597061eec79917d28c1dc31173842d803b72b672493b", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/TASK.json", + "sha256": "62ff5cf498da7487dba4353701753012b6a099058ab725fa754d3bdddd0b16d9", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/VALIDATION.md", + "sha256": "b0775dbf9eb2a0ed535cc932564e9f4480d11df8e42482ef74007d4837d8a434", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/VERIFY.json", + "sha256": "6f38909376177c4ee0c792d4874c3e001845e3b8a4232f6536986e54bd22cda0", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/check_crt_cost.py", + "sha256": "ba01ba42c5cbce8b8fd0ee9adedaf80a8ae3a17656e1a6c6555bb80b3a8dcb1e", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/check_crt_runtime.py", + "sha256": "96a0136758b701b4b547b8c852b8d1cd95f098d0df7001c9794d206351fc7913", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_converter.py", + "sha256": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_descriptor.py", + "sha256": "4bd7674ea79693fb0617378a9de600eab6da2b8c15afd55a969c5e741a198b2e", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_offsets.py", + "sha256": "3b130990f37a844c39722eeed3de7af45aeca6640972333c762e96e6d0df7cd7", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_padding.py", + "sha256": "a827e88a57fbd96e1b61cbc105fe24233f07c7cef71527f495819c8f9fb245f3", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_shape.py", + "sha256": "4073253569e5941de30e26b9ed83b9f1fcdb2c186b20123c7757f2edd7e2153a", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_shear.py", + "sha256": "2ab51279388abceeb8a1e4a335c207236da60d9c62c7e0f633b39cca11abee46", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_sources.py", + "sha256": "6a7e28fb2b3584a382ddec57902fcdd963d3af7c241a4541023666aba7f3d140", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/crt_streams.py", + "sha256": "21147240ab87d5662b0b8219ab3b51d95bc9766cd52e1ec458e5cc015a38fea8", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/encoded_crt.py", + "sha256": "10ebb779490ecb21e11a441db60272e825f328f08ae9cb55b4ee88c37b8027ed", + "binding": "PR5095 declared input" + }, + { + "path": "research/crt-address-streams/verify.py", + "sha256": "c5e49d21f7352ee45c6580a81211bc5b56f71dbcf6df1505b0df5df5538ce9e3", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/ARITHMETIC.md", + "sha256": "bf809380781faf39227b363aa1abd388694a4c26cac48548a3595d1aa0673440", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/CATALOGUE.md", + "sha256": "cd5ae4581a4f24304c33f583ba17f26f8bea81e6ca5cad1d73c663d832863357", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/EVIDENCE.md", + "sha256": "cc56d97456741d927f7ae7c78819bf035aaddd18ab6c26a759dc7a1f92b4baa2", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/PROOF.md", + "sha256": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/README.md", + "sha256": "558acbb1c6501c6d2bbfa8979200112e908c5aa8147e4ddf12adc85329af6eff", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/SOURCES.json", + "sha256": "d37382a6a63dcf96625a7d59489abd52a25fa539a8d7e9007667d93b85d5bd54", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/TASK.json", + "sha256": "c38a634e552c4743611036635ff77032a7face5272752bd5b0fef2921414c4f8", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/VERIFY.json", + "sha256": "d899873897296891c2878c41513b2d6fa92f1db2e99c104be4342d527c77acbe", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/inputs/chirp-export.tar.gz", + "sha256": "931ed8c764ea6cc592cb59ae93f8284184139a4d174752fb80f7a42762b2c0ad", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/inputs/expansion-export.tar.gz", + "sha256": "05146ca4feabe3dde0ab57aaea3eff9f218933562ba5b5c80bb256a247c144c7", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/inputs/headroom-source.tar", + "sha256": "49fd9c1d28809795d109003b4af8d667e22bbc950a75820cf7fb9986d8ac74c6", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/inputs/p48-catalogue-v2.tar.gz", + "sha256": "7e10a7344d19674c68cc64537cbec48b2ff038a907ca00f92fab1c41aaae9af8", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_arithmetic.py", + "sha256": "5e82e32f3afe8e91d4bb9ca531ecc30c836fed951c594e9482af96a472ab130a", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_catalogue.py", + "sha256": "1c22cbfe62f644d500a00cccf6f9dbd16b1c659fcb3b9f70d51770bc9b092d20", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_arithmetic.py", + "sha256": "3899e1734723b7ba9cb1331f8fb61c0a5bd3b4540af45831323a587101df759f", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_budget.py", + "sha256": "5088866fc0762b3ca9caa97e0b681ad29912fdd001393584233bd9d7bba265db", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_catalogue.py", + "sha256": "f9edaca382a499c2293c3e6ca13d118d7938f4b919bd7c6227d64b74b5768a4a", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_counts.py", + "sha256": "2c9577752dbad52232e15ad4e1dbd7e3cc556642651a769161cf1cc67b296057", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_division.py", + "sha256": "8930941cbdd00042e5272860d831bb5d27c27547b09880b5a8bb09314ae02e46", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_full.py", + "sha256": "b3448653ed845e174e37f616793983b8a23f0f82fa1c02cf038cfba1e405a9ba", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_gather.py", + "sha256": "038acf5beb847a31d51df795c4bc173dc45092fc747a09eda9bcb5f28a785d70", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_moves.py", + "sha256": "63b584d06bcd2a3f935f8e53389c2a0a3e05bd66d86a4dd0e9f1fae6690bf11f", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_plan.py", + "sha256": "68480a2195d76d8d4e32252629429ffd4702f1df5380918c1cfa69d939010431", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_records.py", + "sha256": "992132d09f84d343e131b4d40909e276aa4af00e0e0b3e16e53aacf98093f12a", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_router.py", + "sha256": "65b6ce689ce0ff4fa6037a81922cf582b7fab5b5f42921ffeb67cddecd7f51eb", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_sources.py", + "sha256": "fc637a849a20ffec369a9d29693535e0c7c2edbba233a6c10595391f831c6da5", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_twiddles.py", + "sha256": "a2fdbcc7a3787239a74427b4e2c1804a5d0b7fbd2285b442fd6c4bedb58ffe46", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_windows.py", + "sha256": "86e2c3742de5b53d9e85d5d4b865cd7be0dae06acfbf7a1ceca5aa68d41d9f51", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_check_word.py", + "sha256": "60f7a1ec734c8e511ee486360e1de156ef7324db394768ee214116c53ec92c8d", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_counts.py", + "sha256": "01a2e0a836d71e899f3129b47c5923a6c525ee5d20f6679e2930692242cb5eea", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_division.py", + "sha256": "ff1ee517fab590219d569f96696a85f085c7b0a46871372b4b0a55ed8180259a", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_engine.py", + "sha256": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_fixture.py", + "sha256": "f699d1c52334f42fe548b71c199a79381a980fb351c77515acd107f848cf100b", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_gather.py", + "sha256": "47c33983ed41b484836bb4ba3831c4f6506d48c7c23bd948c55906622a55ded0", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_lines.py", + "sha256": "66bac95bdcdf788978d185e2f7508cd74152801f1513c4e5af978ff5983fc511", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_model.py", + "sha256": "2de4aaf4e13d1c711bd7ba5bb10b361454867dfb5384fd34883efbb09897f42c", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_moves.py", + "sha256": "65fedbf5aad4922cd4ba24a6f2aef339d7428dba3f051bf8e647800ab1c1818d", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_plan.py", + "sha256": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_records.py", + "sha256": "a450cbee0b899c0e14dbd43147e73138786846ac009c6626dbcb96292458bb6b", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_router.py", + "sha256": "cf6d7c58396517d15a28f836676d1da679b68796b48b0f780f6131c8a1d2b2fa", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_signed.py", + "sha256": "1cf33e9ff482a19ec808be33ebd29166895faa70e9dd770dc02da313fe448644", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_sources.py", + "sha256": "cba69b2bc93b7dabbffdbdf07fb41130fde5d65a8f4d344ade52d3a326e30ac0", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_twiddles.py", + "sha256": "bd19438b8e261eb9e82029115e2e66e83a5cde161ef9d82a626acd862dfc092f", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_windows.py", + "sha256": "c6554a2d07754af2bf562dc63259bcc57c8d518f3259d0a536b2468af7b4122d", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/tensor_word.py", + "sha256": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-gaussian-tensor/verify.py", + "sha256": "9a6cf1edcadee4b411644a880149937b76fb40df942ea7a6562aa380993dfbe5", + "binding": "PR5095 declared input" + }, + { + "path": "upstream/build/sections/07-resampling.tex", + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "binding": "PR5095 declared input" + }, + { + "path": "upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "binding": "PR5095 declared input" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/PROOF.md", + "sha256": "4916ea5499e1da9343bb09a64f846e61d205f1019f327bd1728ba6b5616e9685", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/README.md", + "sha256": "baedb2a45d1cde2a9a961685af48cdc3f0c51c6d27190ee1942ff33fce1b6840", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/RESULT.json", + "sha256": "7a4102435f0d2c3d0615ea2fbc68622e10a994bca6c222d24cd166988738a916", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/SOURCES.json", + "sha256": "a27cf9d637009403d3ab1e766590ef1bc6db8fdc364dfab3bfe0b76e5c8f8354", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/TASK.json", + "sha256": "9ee1b8668ca89cf517eecbef625685552a330ab351094d000a2dd865e66fe178", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/VERIFY.json", + "sha256": "899f36384f944c7ec0638d5e4670d5c7e1155477f01b5a5515f20d7a16695b2a", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/entry_controls.py", + "sha256": "749924bf2fa6729e69ca0328e5e7396544fdeef9d84206a96e9876cbdc86c587", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/prepare_fixture.py", + "sha256": "e2e816a85a2edf5c3e461893734f1216645d9405478468b1e17ecf14af3c3fbe", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/sandwich.py", + "sha256": "1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/sandwich_reference.py", + "sha256": "f32a66413d71aaba636121eeb9c87b2fad6c64b307795645b89df787022fd311", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/sandwich_sources.py", + "sha256": "61cd1c49e153bc0db5621867076fd69a82e5da629601be7661a24e01bb8e9acf", + "binding": "public PR5095 file" + }, + { + "path": "research/physical-tensor-crt-sandwich-recovery/verify.py", + "sha256": "3ff06b31973d12a6bea444d42caf0eae52802471ad305f72768601a49cfef11d", + "binding": "public PR5095 file" + } + ], + "fixture_sha256": "7dd7adbe9e8f6d5ffbecd425a72827b31d7222ee51bcd67a4148ebfd03420381", + "prior_method_leaf_sha256": "78d0d34cd050e7c5b0678c3a36bc84c01bb9ac9de980ce9ee794e0f6a12a4780", + "whole_caller_harness_review_pending": false, + "harness_sha256": "5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671", + "full_plan_sha256": "e7cbd0cc8e3d129f023a847ec7de097edc72459cc452dafdd92246ed96496e07", + "plan_freeze_sha256": "05f2eaab810898aeccdb3ae31ef9638ccc529d2f9a85f1f6fe27303fdbad51d3", + "review_scope": "Static PASS for root consideration of one separately authorized reduced whole-call fixture; no numerical execution permission.", + "numeric_Tensor_calls_authorized_by_reviewer": 0 +} diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_attempt2_static.py b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_attempt2_static.py new file mode 100644 index 0000000000..083a040618 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_attempt2_static.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Minimal read/hash/AST gate only; never imports the proposed harness.""" +import ast +import difflib +from hashlib import sha256 +import json +from pathlib import Path + +HERE=Path(__file__).resolve().parent +AUTHOR=HERE.parent/'real-packed-outer-consumer-20261023' +def need(x,m): + if not x:raise ValueError(m) +def digest(p):return sha256(p.read_bytes()).hexdigest() +def dump(n):return ast.dump(n,include_attributes=False) +old=AUTHOR/'run_full_packed_DRAFT.py' +new=AUTHOR/'run_full_packed_attempt2_DRAFT.py' +need(digest(old)=='5797e4a8bc6bb69403db119f7740abc41c590484225103120087fe46e9acd671','preserved prior harness') +need(digest(new)=='c7bb6a705f42469709995f7d8a4c29ab0c12764d744546508a443151ec0345dc','exact new static harness') +freeze=json.loads((AUTHOR/'FULL-ATTEMPT2-STATIC-FREEZE.json').read_text()) +need(not freeze['executed'] and not freeze['execution_authorized'],'no attempt2 execution authorization in proposal') +for name,h in freeze['files'].items():need(digest(AUTHOR/name)==h,'new proposal binding '+name) +backup=json.loads((AUTHOR/'full-attempt1-frozen/SHA256SUMS.json').read_text()) +for name,h in backup.items(): + need(digest(AUTHOR/name)==h,'original attempt1 artifact preserved '+name) + need(digest(AUTHOR/'full-attempt1-frozen'/name)==h,'attempt1 backup identical '+name) +patch=''.join(difflib.unified_diff(old.read_text().splitlines(True),new.read_text().splitlines(True),fromfile='frozen-attempt1/run_full_packed_DRAFT.py',tofile='proposed-attempt2/run_full_packed_attempt2_DRAFT.py')) +need(patch==(AUTHOR/'FULL-ATTEMPT2-HARNESS-DIFF.patch').read_text(),'exact diff matches frozen harness pair') +ot,nt=ast.parse(old.read_text()),ast.parse(new.read_text()) +of={n.name:n for n in ast.walk(ot) if isinstance(n,ast.FunctionDef)} +nf={n.name:n for n in ast.walk(nt) if isinstance(n,ast.FunctionDef)} +for name in ('need','hashes','heartbeat','capture'): + need(dump(of[name])==dump(nf[name]),'unchanged helper '+name) +class RemoveCheckpoint(ast.NodeTransformer): + def visit_Expr(self,n): + if isinstance(n.value,ast.Call) and isinstance(n.value.func,ast.Name) and n.value.func.id=='checkpoint_completed_children':return None + return self.generic_visit(n) +for name in ('observe_tensor','observe_converter','observe_pointwise'): + transformed=RemoveCheckpoint().visit(ast.parse(ast.unparse(nf[name]))).body[0] + need(dump(transformed)==dump(of[name]),'observer differs only by post-match checkpoint '+name) +selected={'machine.run','machine.consume','original_tensor','original_converter','original_pointwise','Tensor','Converter','full','p48_setup','no_decode'} +def scientific_calls(tree): + return [dump(n) for n in ast.walk(tree) if isinstance(n,ast.Call) and ast.unparse(n.func) in selected] +need(scientific_calls(ot)==scientific_calls(nt),'all scientific/ownership calls unchanged') +for name in ('FIRST','SECOND','P','ROOT','PKG','DRAFT'): + def assignments(t): + return [dump(n) for n in ast.walk(t) if isinstance(n,ast.Assign) and any(isinstance(x,ast.Name) and x.id==name for x in n.targets)] + need(assignments(ot)==assignments(nt),'same fixture/path '+name) +checkpoint=nf['checkpoint_completed_children'] +checkpoint_calls=[ast.unparse(n.func) for n in ast.walk(checkpoint) if isinstance(n,ast.Call)] +need(all(x in checkpoint_calls for x in ('json.dump','target.flush','os.fsync','temporary.replace')),'flush/fsync then atomic replace implementation') +need(set(nf)-set(of)=={'checkpoint_completed_children'},'only new function is evidence checkpoint') +need("R['deadline_triggered']=True" in new.read_text(),'deadline flag retained before raising') +receipt=json.loads((AUTHOR/'FULL-PACKED-RESULT.json').read_text()) +need(receipt['status']=='FAIL' and receipt['Tensor_calls']==2 and receipt['Converter_calls']==2,'preserved incomplete first outcome') +need(receipt['source_and_candidate_unchanged'] and receipt['harness_unchanged'],'prior exact-byte integrity') +need('TimeoutError' in receipt['traceback'] and 'empty body before owned marker erasure' in receipt['traceback'],'deadline and inherited cleanup failure visible') +need('actual_Tensor_observations' not in receipt,'first-attempt durability gap preserved rather than repaired retrospectively') +for path,h in receipt['before_hashes'].items():need(digest(AUTHOR/path)==h,'same original scientific inputs '+path) +log=(AUTHOR/'FULL-PACKED.log').read_text() +need(log.count('NUMERICAL_TENSOR_FINISH 0')==1 and 'NUMERICAL_TENSOR_FINISH 1' not in log,'one logged successful full Tensor return, no opposite completion') +need('NUMERICAL_TENSOR_START 1 True' in log,'second/opposite started before deadline') +for filename in ('FULL-PACKED-ATTEMPT2-RESULT.json','FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json','FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json.tmp','FULL-PACKED-ATTEMPT2.log'): + need(not(AUTHOR/filename).exists(),'fresh attempt2 evidence path '+filename) +result={'status':'PASS_MINIMAL_ATTEMPT2_STATIC_DURABILITY_GATE','no_numeric_execution':True, + 'new_harness_sha256':digest(new),'prior_harness_sha256':digest(old), + 'addendum_sha256':digest(AUTHOR/'FULL-ATTEMPT2-PLAN-ADDENDUM.md'), + 'exact_diff_sha256':digest(AUTHOR/'FULL-ATTEMPT2-HARNESS-DIFF.patch'), + 'prior_receipt_sha256':digest(AUTHOR/'FULL-PACKED-RESULT.json'), + 'prior_backup_files_verified':len(backup),'all_original_source_input_hashes_preserved':True, + 'scientific_and_ownership_call_ASTs_unchanged':True,'observer_changes_only_post_match_checkpoint':True, + 'fresh_attempt2_evidence_paths':True,'proposed_external_cap':900,'proposed_internal_alarm':880, + 'durability_scope':'Matched completed-stage records, atomic whole-file replacement and process-failure retention; no whole-caller-success or power-loss persistence claim.', + 'remaining_limits':['No observed opposite/recovery/postconditions from attempt1','Inherited deadline/numerical-child cleanup not repaired','Four full-stage mutants remain unrun','require_recovery=False remains diagnostic','No execution authorized by this reviewer']} +(HERE/'ATTEMPT2-STATIC-RESULT.json').write_text(json.dumps(result,indent=2)+'\n') +print(result['status'],'no numerical import/execution') diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_postrun.py b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_postrun.py new file mode 100644 index 0000000000..8465d08bba --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_postrun.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +"""Independent host-integer evidence audit; no Tensor/cohort/factory imports.""" +from hashlib import sha256 +import json +from pathlib import Path + +HERE=Path(__file__).resolve().parent +AUTHOR=HERE.parent/'real-packed-outer-consumer-20261023' +def need(x,m): + if not x:raise ValueError(m) +def digest(p):return sha256(p.read_bytes()).hexdigest() +def bits_hash(bits): + need(all(type(b) is int and b in (0,1) for b in bits),'literal bit array') + return sha256(bytes(bits)).hexdigest() +def words(bits,width,count): + need(len(bits)==width*count,'exact full signed record length') + bits_hash(bits);out=[] + for i in range(count): + row=bits[i*width:(i+1)*width] + x=sum(b<>j)&1 for v in values for j in range(width)] +def encode_complex(values):return encode_words([v for pair in values for v in pair],50) +def crt(v): + out=[None]*35 + for k,x in enumerate(v):out[(k%5)*7+(3*k%7)]=x + return out +def inverse_crt(v):return [v[(k%5)*7+(3*k%7)] for k in range(35)] +def truncate(v,shift):return (-1 if v<0 else 1)*(abs(v)>>shift) +def nearest(v,shift):return (-1 if v<0 else 1)*((abs(v)+(1<<(shift-1)))>>shift) + +freeze=json.loads((AUTHOR/'FULL-ATTEMPT2-FREEZE.json').read_text()) +for name,h in freeze['files'].items():need(digest(AUTHOR/name)==h,'frozen postrun evidence '+name) +receipt_path=AUTHOR/'FULL-PACKED-ATTEMPT2-RESULT.json' +r=json.loads(receipt_path.read_text()) +c=json.loads((AUTHOR/'FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json').read_text()) +need(r['status']=='PASS_ACTUAL_TWO_TENSOR_STAGED_PACKED_CALLER','actual successful staged endpoint') +need(r['before_hashes']==r['after_hashes'],'recorded source/candidate hashes unchanged') +for path,h in r['before_hashes'].items():need(digest(AUTHOR/path)==h,'current scientific bytes '+path) +need(r['harness_sha256']==r['harness_after_sha256']==digest(AUTHOR/'run_full_packed_attempt2_DRAFT.py')=='c7bb6a705f42469709995f7d8a4c29ab0c12764d744546508a443151ec0345dc','exact reviewed executed harness') +need(r['source_and_candidate_unchanged'] and r['harness_unchanged'],'integrity flags') +need(r['Tensor_calls']==2 and r['Converter_calls']==3 and r['injected_child_dispatches']==1,'exact dispatch counts') +ts,cs=r['actual_Tensor_observations'],r['actual_Converter_observations'] +need(len(ts)==2 and len(cs)==3,'durable completed return counts') +need(c['actual_Tensor_observations']==ts and c['actual_Converter_observations']==cs,'durable checkpoint/receipt child equality') +need(c['actual_pointwise_bits']==r['arrays']['actual_pointwise_bits'],'durable checkpoint/receipt product equality') +need(c['harness_sha256']==r['harness_sha256'] and c['candidate_sha256']==r['before_hashes']['packed_sandwich_DRAFT.py'],'checkpoint identity') +stage_hashes=[] +for item in ts+cs: + need(bits_hash(item['raw_bits'])==item['return_sha256'],'actual return hash') + if 'input_raw_bits' in item:need(bits_hash(item['input_raw_bits'])==item['input_sha256'],'actual CRT input hash') + stage_hashes.append(item['return_sha256']) +need([x['opposite'] for x in ts]==[False,True],'forward/opposite flags') +need([x['inverse'] for x in cs]==[False,False,True],'two forward CRT/one inverse') +digits1,digits2=r['independent_digit_streams'] +need(digits1==[255,0,3,17] and digits2==[1,254,0,9],'frozen independent fixture') +naturals=[] +for digits,observation in zip((digits1,digits2),cs): + ingress=[(v<<(48-8-2),0) for v in digits]+[(0,0)]*31 + need(complex_words(observation['input_raw_bits'])==ingress,'actual physical ingress records') + natural=complex_words(observation['raw_bits']) + need(natural==crt(ingress),'independent exact CRT orientation') + need(all(im==0 for _,im in natural),'real converted input') + naturals.append(natural) +packed=[(u[0],v[0]) for u,v in zip(*naturals)] +need(bits_hash(encode_complex(packed))==ts[0]['input_sha256'],'actual packed Tensor input from actual CRT returns') +need(all(a*a+b*b<(1<<94) for a,b in packed),'strict packed half-disk input') +forward=complex_words(ts[0]['raw_bits']) +need([list(x) for x in forward]==r['arrays']['expected_forward'],'all35 actual forward records match frozen staged target') +reflected=[forward[((-i)%5)*7+((-j)%7)] for i in range(5) for j in range(7)] +need([list(x) for x in reflected]==r['arrays']['expected_J'],'J of captured actual H matches target') +product=[] +for (a,b),(c0,d) in zip(forward,reflected): + ar,ai,br,bi=a+c0,b-d,b+d,c0-a + need(all(-(1<<50)<=v<(1<<50) for v in (ar,ai,br,bi)),'widened51bit raw split headroom') + # Four-split-product formula is independent of the author's squared formula. + rr,ii=ar*br-ai*bi,ar*bi+ai*br + need(rr==2*a*b+2*c0*d and ii==-a*a+b*b+c0*c0-d*d,'exact split-product identity') + product.append((truncate(rr,50),truncate(ii,50))) +actual_product=complex_words(r['arrays']['actual_pointwise_bits']) +need(product==actual_product,'host exact raw-split/shift50 result equals physical product') +need([list(x) for x in product]==r['arrays']['expected_product'],'all35 product target records') +need(bits_hash(encode_complex(product))==ts[1]['input_sha256'],'actual opposite input is actual once-truncated product') +need(all(a*a+b*b<=(1<<94) for a,b in product),'actual opposite half-disk input') +opposite=complex_words(ts[1]['raw_bits']) +need([list(x) for x in opposite]==r['arrays']['expected_opposite'],'all35 actual opposite target records') +need(all(pair==(0,0) for pair in opposite),'observed opposite result is zero') +recovered=[nearest(a*35*35*(1<<20),48) for a,_ in opposite] +need(words(cs[2]['input_raw_bits'],86,35)==recovered,'host twoS/shift20/nearest recovery from captured opposite') +ordinary=inverse_crt(recovered) +need(words(cs[2]['raw_bits'],86,35)==ordinary,'actual inverse CRT of recovered records') +need(ordinary==r['arrays']['expected_coefficients'],'all35 ordinary coefficient target') +diagnostic=sum(v*256**i for i,v in enumerate(ordinary)) +expected_bits=[(diagnostic>>i)&1 for i in reversed(range(64))] +need(r['output_bits']==expected_bits and len(expected_bits)==64,'exact prescribed carry bits') +need(bits_hash(expected_bits)==r['output_sha256'],'actual output hash') +true=sum(v*256**i for i,v in enumerate(digits1))*sum(v*256**i for i,v in enumerate(digits2)) +need(diagnostic==r['staged_integer']==0 and true==r['true_integer']==43113955509404415,'prominent diagnostic versus true values') +need(r['diagnostic_difference']==diagnostic-true==-43113955509404415 and not r['diagnostic_equals_true_product'],'mismatch retained') +need(not r['require_recovery'] and not r['production_recovery_claim'],'no production admission') +need(r['actual_counts']==dict(conversions=3,transforms=2,pointwise_products=1,packed_records=35,J_axis_passes=2,split_records=35,split_exact_adds=140,pointwise_real_products=140),'finite parent counters') +tensor_counts=dict(natural_padding=4,gathers=4,halos=4,expansion_axes=2,compression_axes=2,assembled_axes=2,chirps=1) +need(all(t['complete_child_counts']==tensor_counts for t in ts),'perTensor complete stage counters') +for ob in cs: + counts=ob['complete_child_counts'] + need(counts==dict(global_routes=1,triangular_shifts=2,padding_passes=2,router=dict(batches=1,edges=3,involutions=2,literal=1)),'perCRT stage counters') +for name in ('pending_end_head_rejected','consume_and_reuse_policy_checked','borrowed_values_heads_restored','metadata_values_heads_restored','resident_empty_origin_checks'): + need(r[name] is True,'executed lifecycle assertion '+name) +need(r['injected_failure_cut']=='first Converter dispatch before original child operation','limited injected failure cut') +log=(AUTHOR/'FULL-PACKED-ATTEMPT2.log').read_text() +need(all(log.count(s)==1 for s in ('NUMERICAL_TENSOR_START 0 False','NUMERICAL_TENSOR_FINISH 0','NUMERICAL_TENSOR_START 1 True','NUMERICAL_TENSOR_FINISH 1')),'log confirms two numerical starts/finishes') +backup=json.loads((AUTHOR/'full-attempt1-frozen/SHA256SUMS.json').read_text()) +for name,h in backup.items(): + need(digest(AUTHOR/name)==h and digest(AUTHOR/'full-attempt1-frozen'/name)==h,'earlier failure unchanged '+name) +nonzero=lambda values:sum(a!=0 or b!=0 for a,b in values) +need((nonzero(forward),nonzero(product),nonzero(opposite))==(28,35,0),'nonzero stage census') +result={'status':'PASS_INDEPENDENT_POSTRUN_STAGED_EVIDENCE_REVIEW', + 'no_numeric_replay_or_cohort_import':True,'observed_integer':diagnostic,'staged_integer':r['staged_integer'], + 'true_integer':true,'observed_minus_true':diagnostic-true,'accurate_integer_recovery_claim':False, + 'receipt_sha256':digest(receipt_path),'checkpoint_sha256':digest(AUTHOR/'FULL-PACKED-ATTEMPT2-CHILD-CHECKPOINT.json'), + 'completed_Tensor_returns':2,'completed_CRT_returns':3,'records_each':35, + 'signed_component_bits':50,'inverse_CRT_record_bits':86,'output_bits':64, + 'raw_return_lengths':[len(x['raw_bits']) for x in ts+cs], + 'raw_return_hashes':stage_hashes,'independent_physical_product_sha256':bits_hash(encode_complex(product)), + 'source_and_candidate_current_hashes_checked':len(r['before_hashes']), + 'nonzero_records':{'forward':28,'product':35,'opposite':0}, + 'product_max_squared_norm_numerator':max(a*a+b*b for a,b in product),'squared_norm_denominator':1<<96, + 'normal_lifecycle_flags_and_exact_harness_assertions_verified':True, + 'failure_cut':'pre-firstConverter dispatch only; earlier deadline numerical-child cleanup failure remains', + 'seconds_reported':r['seconds'],'all_prior_failure_artifacts_preserved':True, + 'limits':['No production accuracy/admission','Zero opposite makes recovery normalization check degenerate','Four full-stage mutations unrun','No full priced tariff or matched speedup','No recursive moment/compiler reserve/kappa claim']} +(HERE/'POSTRUN-CHECK-RESULT.json').write_text(json.dumps(result,indent=2)+'\n') +print(result['status'],'observed=0 true=43113955509404415 difference=-43113955509404415') diff --git a/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_static.py b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_static.py new file mode 100644 index 0000000000..3a1c965ffd --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/packed-caller-independent-gate-20261023/check_static.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Source/AST-only independent gate. Never imports cohort or numerical code.""" +import ast +from hashlib import sha256 +import json +from pathlib import Path + +HERE=Path(__file__).resolve().parent +AUTHOR=HERE.parent/'real-packed-outer-consumer-20261023' +ROOT=AUTHOR/'staged-source' +PKG=ROOT/'research/physical-tensor-crt-sandwich-recovery' + +def digest(path):return sha256(path.read_bytes()).hexdigest() +def dump(node):return ast.dump(node,include_attributes=False) +def cls(tree):return next(x for x in tree.body if isinstance(x,ast.ClassDef)) +def methods(tree):return {x.name:x for x in cls(tree).body if isinstance(x,(ast.FunctionDef,ast.AsyncFunctionDef))} + +source=AUTHOR/'SOURCE-sandwich.py';draft=AUTHOR/'packed_sandwich_DRAFT.py' +assert digest(source)=='1d45e8deed1b138fcd9800cc563b8cd894cbd2d072033ba23215566d299a4325' +assert digest(draft)=='5dfcdfe63d9d03a89a00dd92e681ab0a0efc5bbc86aa7edae58f007baf752483' +assert source.read_bytes()==(PKG/'sandwich.py').read_bytes() +st,dt=ast.parse(source.read_text()),ast.parse(draft.read_text()) +sm,dm=methods(st),methods(dt) +unchanged=[name for name in sm if dump(sm[name])==dump(dm[name])] +assert set(unchanged)=={'__init__','consume','child','ingress','recover','carries','admit'} +sg=next(x for x in st.body if isinstance(x,ast.FunctionDef) and x.name=='private_tapes') +dg=next(x for x in dt.body if isinstance(x,ast.FunctionDef) and x.name=='private_tapes') +assert dump(sg)==dump(dg) +def imports(tree): + return {(getattr(x,'module',None),n.name,n.asname) for x in tree.body if isinstance(x,(ast.Import,ast.ImportFrom)) for n in x.names} +assert imports(st)<=imports(dt) +assert imports(dt)-imports(st)=={('compact_counts','copy_bits',None),('ring_words','add',None),('ring_words','difference',None)} +sr,dr=sm['run'],dm['run'] +assert dump(sr.args)==dump(dr.args) +sto=next(x for x in sr.body if isinstance(x,ast.Try));dto=next(x for x in dr.body if isinstance(x,ast.Try)) +assert [dump(x) for x in sto.finalbody]==[dump(x) for x in dto.finalbody] +sti=sto.body[0].body[0];dti=dto.body[0].body[0] +assert isinstance(sti,ast.Try) and isinstance(dti,ast.Try) +assert [dump(x) for x in sti.finalbody]==[dump(x) for x in dti.finalbody] +assert [dump(x) for x in sr.body[-2:]]==[dump(x) for x in dr.body[-2:]] +for name in ('pack_real','move_bits','negate_frequencies','pointwise','run'): + assert not any(isinstance(n,ast.Call) and isinstance(n.func,ast.Name) and n.func.id=='Tape' for n in ast.walk(dm[name])) +calls=[] +for n in ast.walk(dr): + if isinstance(n,ast.Call) and isinstance(n.func,ast.Attribute) and n.func.attr=='child': + calls.append({'operation':ast.unparse(n.args[0]),'line':n.lineno,'options':{k.arg:ast.unparse(k.value) for k in n.keywords}}) +assert sum(x['operation']=='self.tensor.run' for x in calls)==2 +assert [x for x in calls if x['operation']=='self.tensor.run' and x['options'].get('opposite')=='True'] +assert sum(x['operation']=='self.converter.run_plan' for x in calls)==2 +assert [x for x in calls if x['operation']=='self.converter.run_plan' and x['options'].get('inverse')=='True'] +checks=[] +for row in json.loads((PKG/'SOURCES.json').read_text())['files']: + if row['usage']=='input': + path=ROOT/row['path'];assert not path.is_symlink() and digest(path)==row['sha256'] + checks.append({'path':row['path'],'sha256':row['sha256'],'binding':'PR5095 declared input'}) +for row in json.loads((AUTHOR/'PUBLIC-TEXT-MANIFEST.json').read_text()): + path=ROOT/row['path'];assert not path.is_symlink() and digest(path)==row['sha256'] + checks.append({'path':row['path'],'sha256':row['sha256'],'binding':'public PR5095 file'}) +fixture=PKG/'inputs/p48-5x7.bin' +assert digest(fixture)=='7dd7adbe9e8f6d5ffbecd425a72827b31d7222ee51bcd67a4148ebfd03420381' +leaf=json.loads((AUTHOR/'METHOD-LEAF-RESULT.json').read_text()) +assert leaf['status']=='PASS_BOUNDED_PHYSICAL_METHOD_LEAF' +assert leaf['numerical_Tensor_calls']==leaf['numerical_Converter_calls']==0 +assert leaf['all_consumed_source_and_draft_hashes_unchanged'] +freeze=json.loads((AUTHOR/'FULL-PLAN-FREEZE.json').read_text()) +for filename, expected in freeze['files'].items():assert digest(AUTHOR/filename)==expected +assert freeze['execution_authorized'] is False and freeze['executed'] is False +harness=AUTHOR/'run_full_packed_DRAFT.py' +ht=ast.parse(harness.read_text()) +# This parses the proposed program as data; it does not execute its imports. +assert any(isinstance(n,ast.Call) and isinstance(n.func,ast.Attribute) and n.func.attr=='run' + and isinstance(n.func.value,ast.Name) and n.func.value.id=='machine' + and any(k.arg=='require_recovery' and isinstance(k.value,ast.Constant) and k.value.value is False for k in n.keywords) + for n in ast.walk(ht)) +for name in ('observe_tensor','observe_converter'): + fn=next(n for n in ast.walk(ht) if isinstance(n,ast.FunctionDef) and n.name==name) + cleanup=next(n for n in ast.walk(fn) if isinstance(n,ast.ExceptHandler) and isinstance(n.type,ast.Name) and n.type.id=='BaseException') + assert any(isinstance(n,ast.Call) and ast.unparse(n.func)=='returned.clear' for n in ast.walk(cleanup)) + assert any(isinstance(n,ast.Call) and isinstance(n.func,ast.Name) and n.func.id=='erase_marker' for n in ast.walk(cleanup)) +assert 'FAIL_SOURCE_OR_HARNESS_DRIFT' in harness.read_text() +result={'status':'PASS_STATIC_DRAFT_AND_SOURCE_BINDING','no_numeric_execution':True, + 'source_head':'e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1', + 'source_sha256':digest(source),'draft_sha256':digest(draft), + 'unchanged_methods':unchanged,'private_owner_graph_unchanged':True, + 'original_imports_retained':True,'new_imports':['compact_counts.copy_bits','ring_words.add','ring_words.difference'],'outer_and_inner_run_finally_unchanged':True, + 'literal_recovery_default_and_pending_return_tail_unchanged':True, + 'new_methods_and_run_allocate_no_Tape':True,'static_child_callsites':calls, + 'note':'Converter forward callsite lies in two-input loop: three total conversions. Two Tensor callsites total, latter opposite.', + 'authenticated_inputs':checks,'fixture_sha256':digest(fixture), + 'prior_method_leaf_sha256':digest(AUTHOR/'METHOD-LEAF-RESULT.json'), + 'whole_caller_harness_review_pending':False, + 'harness_sha256':digest(harness),'full_plan_sha256':digest(AUTHOR/'FULL-CALLER-PLAN.md'), + 'plan_freeze_sha256':digest(AUTHOR/'FULL-PLAN-FREEZE.json'), + 'review_scope':'Static PASS for root consideration of one separately authorized reduced whole-call fixture; no numerical execution permission.', + 'numeric_Tensor_calls_authorized_by_reviewer':0} +(HERE/'STATIC-RESULT.json').write_text(json.dumps(result,indent=2)+'\n') +print(result['status'],len(checks),'manifest file checks; no cohort imports') diff --git a/research/real-packed-tensor-staged-caller/evidence/pr5095-head-update-0938.json b/research/real-packed-tensor-staged-caller/evidence/pr5095-head-update-0938.json new file mode 100644 index 0000000000..f84e3cdc76 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/pr5095-head-update-0938.json @@ -0,0 +1,20 @@ +{ + "at": "2026-10-23 09:37:58 UTC", + "from": "e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1", + "to": "467445ad61472f25e8b4d6757f838aceecf4fdec", + "files": [ + { + "sha": "88949e4d119dd52fa530990f68176a52f731b6b6", + "filename": "research/physical-tensor-crt-sandwich-recovery/README.md", + "status": "modified", + "additions": 14, + "deletions": 1, + "changes": 15, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/467445ad61472f25e8b4d6757f838aceecf4fdec/research%2Fphysical-tensor-crt-sandwich-recovery%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/467445ad61472f25e8b4d6757f838aceecf4fdec/research%2Fphysical-tensor-crt-sandwich-recovery%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fphysical-tensor-crt-sandwich-recovery%2FREADME.md?ref=467445ad61472f25e8b4d6757f838aceecf4fdec", + "patch": "@@ -22,7 +22,13 @@ python3.12 -B research/physical-tensor-crt-sandwich-recovery/verify.py --suite l\n python3.12 -O -B research/physical-tensor-crt-sandwich-recovery/verify.py --suite full\n ```\n \n-The second command takes about six minutes. No network, dependencies or\n+The final Git-free optimized full replay took 372.34 seconds locally on\n+macOS arm64 with CPython 3.12.2. This timing is not portable: the\n+[hosted replay](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39928197748/job/120331693703)\n+on Ubuntu 24.04.5 x64 with CPython 3.12.15 passed the leaves in 5.40 seconds\n+but timed out the full command at its unchanged 600-second limit. Full hosted\n+verification is incomplete; the timeout supplies neither a passing result nor\n+an observed arithmetic assertion failure. No network, dependencies or\n coefficient regeneration are required. Optional `prepare_fixture.py OUTPUT_FILE`\n repeats the actual ~251-second producer into a new file; it is not part of replay. The official package export includes\n all source inputs and original notices; nested archives authenticate themselves.\n@@ -36,6 +42,13 @@ identities. No frozen predecessor file or selected frontier is changed.\n \n ## Open next questions\n \n+- Bring the complete continuous owner invocation below the hosted limit with a\n+ proved equivalent optimization. A bounded 20-second diagnostic profile of\n+ the unchanged local run found inherited tape operations and encoded loop\n+ counters dominant in that prefix; it did not measure the complete run. Any\n+ adapter must preserve frame validation, all three transforms and converters,\n+ borrowed inputs, pending-return consumption, and the complete checks.\n+\n - Supply a production-admitted catalogue/native instance and bind its actual\n local analytic errors to the sufficient caller guard.\n - Bind arbitrary n-bit packing and a valid all-size parameter family, including" + } + ], + "verdict": "Only README.md updated; full-hosted portability unresolved, no scientific code delta/packing claim." +} diff --git a/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/CHILD-CENSUS.json b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/CHILD-CENSUS.json new file mode 100644 index 0000000000..5ad2e26183 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/CHILD-CENSUS.json @@ -0,0 +1,15 @@ +{ + "status": "SOURCE_CLOSURE_STOP_NO_RECURSIVE_MOMENT_GAIN", + "scope": "Read-only source decomposition; no fixture/module/native/compiler execution", + "runtime_chain": ["Tensor", "LineApply.compression=Core", "Interior/BandedSolve", "FftWord", "RingProduct"], + "not_bound_as_runtime_children": ["RawGaussian", "Gaussian", "Full"], + "nontrivial_branch": "Core page with N cells having inside length ell > band = 2w; each such cell has ell+2w records", + "real_component_children": {"Interior": "2N", "Convolution": "4N", "FftWord_from_convolutions_only": "16N", "BandedSolve": 1}, + "complex_core_children": {"Interior": "4N", "Convolution": "8N", "FftWord_from_convolutions_only": "32N", "BandedSolve": 2}, + "independent_real_input_dimension": "One complex Core source rectangle carries 2n independent real input coordinates; selected solve uses 2m; returned core has 2k real coordinates. Two real streams in its components use that same dimension, not twice it.", + "component_asymmetry": "Solver call trees identical; input norm checked in first gather and paired norm checked after both outputs; no solver child removed", + "normalized_moment": "(1/(2W))*sum(2*n_r*(r/m)^(1-a)) = (1/W)*sum(n_r*(r/m)^(1-a))", + "native_rank_census": "No actual Gaussian paid-query rank interface is bound to these word/arithmetic calls; cannot substitute call counts for ranks", + "dirty_helper_guard": "Conjugate main inputs do not constrain independent dirty helpers. Both helper inventories require full service and bill, or second helper reward is lost.", + "finite_outer_lead": "5095 two-real forward packing may replace two completed forwards by one, plus the same opposite Tensor; implementation and new numerical/recovery proof remain unpaid; this constant count alone is not kappa improvement" +} diff --git a/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/MANIFEST.json b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/MANIFEST.json new file mode 100644 index 0000000000..8628df3432 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/MANIFEST.json @@ -0,0 +1,10 @@ +{ + "files": { + "REPORT.md": "e48171630c801a906199c9586c0688f7dd40163846a5b4abae64d33d941ccd2e", + "CHILD-CENSUS.json": "4470a3830197f7dc1a2d9cd9fada74b7e7c69f4085f0b2380ce3f431b2e20ea0", + "SOURCES.json": "a3acb57f95f2b6301fe00246b6c56688b9b253c3bb417cf31c1c7a89d8ef8dfd" + }, + "no_executable_fixture": true, + "no_module_imports": true, + "no_native_or_compiler_execution": true +} diff --git a/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/REPORT.md b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/REPORT.md new file mode 100644 index 0000000000..c5a8e807a9 --- /dev/null +++ b/research/real-packed-tensor-staged-caller/evidence/real-hermitian-closure-20261023/REPORT.md @@ -0,0 +1,100 @@ +# The actual Gaussian Core already separates the two real channels + +The proposed real/Hermitian packing does not presently change a normalized recursive rank moment. The actual PR3935 compression Core runs the same real scalar solver twice—once on each component—with the same page, dimensions, shifts and coefficient streams. One complex packet already carries exactly two independent real packets. Relabelling them as two jobs doubles both their real-dimension reward and their scalar child work. A top-level reduction from three complete Tensor calls to two remains a possible finite outer optimization, requiring its own implementation and numerical proof; it supplies no recursive κ gain by itself. + +A source-chain correction is decisive: the inspected runtime is **Tensor → physical Core → Interior/BandedSolve → FftWord → RingProduct**, not Tensor → RawGaussian → Gaussian → Full. The rational-unitary classes belong to a different proof/reference chain. No adapter identifying them as these runtime children was found or assumed. This packet stops the recursive κ claim at that missing interface and the real-work cancellation; it does not claim a universal barrier to real FFT algorithms. + +## Exact sources and read-only scope + +The outer caller is JoyboyBrian's PR5095 head `e65f47db55b9a3779fbf7fe23e93a8a4c5eb3ce1`, `research/physical-tensor-crt-sandwich-recovery/{sandwich.py,sandwich_sources.py,PROOF.md}`. Its exact-head snapshots and authentication are retained in `outputs/outer-bilinear-interface-20261023/appendix5095-sources/` and `APPENDIX-5095-SOURCES.json`; this packet read them without running the loader. The source Tensor is Jose Manuel / jmbarrancoml's PR3935 head `f687fa171ef760fa98a4be1289717b47dd4ee0b3`, `research/physical-gaussian-tensor/`. + +The actual nested source pins declared by those frozen loaders are: + +| Child | Exact head | Source-bearing parent | +|---|---|---| +| physical Gaussian expansion | `1a86a8fb73bb7a0982fff99852a031832c191902` | Tensor `inputs/expansion-export.tar.gz` | +| physical Gaussian Core | `7ab67b4a84d28cd562b9711aa315ca5b47822b37` | expansion `inputs/core-export.tar.gz` | +| physical FFT word | `9b5474f47b0ea9a3c76bb5b1b577fb36704815e0` | Core `inputs/word-export.tar` | +| physical ring product | `62264289adb01f3ba4930cd0154c75887f96203c` | FFT word `inputs/ring-export.tar` | +| branchfree Gaussian reference | `8922e3b3f0fd7772b0fb42028eb2532984c3ab42` | Core `inputs/branchfree-source.tar` | + +`SOURCES.json` records archive SHA256s and text-member hashes. Only selected text members were copied into this packet's `sources/`; no repository module, source loader, constructor, executable fixture or replay was run. The frozen centre0 package was not changed. Monitor scope clearance through #5096 was targeted and is not exhaustive novelty evidence. This packet does not touch Joy's #5018 allocator successor. + +## Complete parent ABI and real dimensions + +PR5095 accepts **two independent** length-q streams of nonnegative radix-2^b digits. Each stream enters as the real array a_j/2^(b+2), padded with S-q zeros; the independent real dimension before padding is q for each operand, hence **2q total**. The two digit streams are retained separately in the bilinear product even if encoded as one complex input. They are not 2q independent complex coordinates. + +The parent executes two forward complete normalized source transforms T=R F_s, the scalar coordinatewise product on every one of S source frequency coordinates, and one complete opposite-sign Tensor. The inverse recovery scale is S²2^(2b+4). Source R is multiplication of the stored frequency indices by the per-axis t_i and commutes with frequency negation. For H=T(a+i b), define H#_j=conj(H_(-j)); the exact packing formula is + + T(a) T(b) = (H²-(H#)²)/(4i). + +Frequency negation is j_i→-j_i mod s_i, with source layout R retained. This is not the index map of the inner physical solver's record reversal. The actual digit bounds a,b<1/4 give |a+i b|