diff --git a/research/trace-curvature-preload/EXPECTED.json b/research/trace-curvature-preload/EXPECTED.json new file mode 100644 index 0000000000..c04f2464c8 --- /dev/null +++ b/research/trace-curvature-preload/EXPECTED.json @@ -0,0 +1,21 @@ +{ + "kappa": "396803113660173/250000000000000000", + "kappa_decimal": "0.001587212454640692", + "bit_lower": "1589735702947998836661/1000000000000000000000000", + "complex_lower": "1589991533606044174031/1000000000000000000000000", + "global_profile": { + "1": 362880, + "2": 395520, + "3": 17280, + "4": 67200, + "6": 49920, + "7": 23040, + "8": 2592 + }, + "word_sha256": "db5cd7ab49e2e58a2924a2a9e68ee69d8165b4d5c008b6f546577f4791019dca", + "template_sha256": "db803cb36bf80b724146c6bfc5d92d6e17dcf6960a0fddbf1ed241f2ab7f7cea", + "emitted_program_sha256": "5406308f8309830a15af38ccd2caca210f5190a3ee5166d41e6053bf8fbea8ac", + "global_prefix_bits": 193, + "two_level_coefficient_bits": 425, + "row_coefficient": 18355 +} diff --git a/research/trace-curvature-preload/MANIFEST.json b/research/trace-curvature-preload/MANIFEST.json new file mode 100644 index 0000000000..52d1f9baf1 --- /dev/null +++ b/research/trace-curvature-preload/MANIFEST.json @@ -0,0 +1,777 @@ +{ + "format": "sha256-lf-text-v1", + "files": { + "appendix/static44/audit_scalar.py": { + "mode": "lf-text", + "sha256": "a1cd720d281c7a9db7f17919c637cdcb8558e9f3c96e929706f0c21f317a7943" + }, + "appendix/static44/build.py": { + "mode": "lf-text", + "sha256": "b15192ff50fd99f5ca3cb5857b5e129c98a212de60ae76aafb1614139743c35a" + }, + "appendix/static44/gk/gk_common.py": { + "mode": "lf-text", + "sha256": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198" + }, + "appendix/static44/gk/gk_word.py": { + "mode": "lf-text", + "sha256": "f027a9273bcf4e0971258c160b7d3b3c196366b32a529cff6e6a0e666b03826b" + }, + "appendix/static44/inputs/BASE535.json.gz": { + "mode": "raw", + "sha256": "edfffb8e8735e0d1f07c81d818022b705ef0889c2bccc193a2f7a661b9f7d390" + }, + "appendix/static44/inputs/OLD-RECIPE.json": { + "mode": "lf-text", + "sha256": "7e5c179246261edd9e1019e81e6e979537f02559da773b993a318f771cb7d763" + }, + "appendix/static44/inputs/RAW504.json.gz": { + "mode": "raw", + "sha256": "1c6144791dbedf6427e3ee7b4c24fb05b5bf407f6346592f50f8dd8d9638108d" + }, + "appendix/static44/LICENSE": { + "mode": "lf-text", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "appendix/static44/META-SOURCES.json": { + "mode": "lf-text", + "sha256": "c8aeb9313f2c671a9a8766c249ceb6cffa106dfdab3ab761da8e8c534b115090" + }, + "appendix/static44/NOTICE-upstream.md": { + "mode": "lf-text", + "sha256": "1547136e6d269fdcef2b68c10a97a786a79a4732a12738363f679bfb282430cd" + }, + "appendix/static44/PROOF.md": { + "mode": "lf-text", + "sha256": "abfa6548b223893866094631aed61174575dc1b17bdd60627b2c55e6b9477e4f" + }, + "appendix/static44/README.md": { + "mode": "lf-text", + "sha256": "51d6ef7ad3e12e72daf29e0260a11cd985a0148fe1efa0574a533dae726c553c" + }, + "appendix/static44/RECIPE.json": { + "mode": "lf-text", + "sha256": "8735ac9beadff3edcb4a4df8dae174415e0f83d9b4df8556c33ba7fd777505fa" + }, + "appendix/static44/replay.py": { + "mode": "lf-text", + "sha256": "fd1ce7d1f8974b473aef8c6cec1e0c590e01d0d215b073e5573a771ce42fc74d" + }, + "appendix/static44/SOURCE-MANIFEST.json": { + "mode": "lf-text", + "sha256": "4f5d92b4cd76eff0845a9f14d33131441535a232b5c91f00535aa076d44c45a8" + }, + "code/assemble_meta.py": { + "mode": "lf-text", + "sha256": "37f44458382b0d2ac42140f92401edf5746d3e8fdb5d5afa9967c96c772a4929" + }, + "code/audit_curvature.py": { + "mode": "lf-text", + "sha256": "5b81ba18969e84c3d10e647dde2ddb1cda81749c68a8bdd66db7d1d09cd363b2" + }, + "code/build_preload60.py": { + "mode": "lf-text", + "sha256": "105641136b565003118f362bb67086e1eeb4910aed6af593a011f60c2b2962b6" + }, + "code/build_static44_portable.py": { + "mode": "lf-text", + "sha256": "b15192ff50fd99f5ca3cb5857b5e129c98a212de60ae76aafb1614139743c35a" + }, + "code/run_global.py": { + "mode": "lf-text", + "sha256": "05698ba40a9a65e3710de8a6a12d4099a8a7ce98088e6739426083f02736b1d9" + }, + "code/run_native.py": { + "mode": "lf-text", + "sha256": "02bda11936adf3d83bacfbc0d5423f053318bc73c485d861eddf6b599c843e8a" + }, + "code/transport_compensation.py": { + "mode": "lf-text", + "sha256": "0fb30defcf40e892d199be840d916ddd61c071c0065c2bfbe7382272fee35724" + }, + "docs/CONTEXT-SOURCES.json": { + "mode": "lf-text", + "sha256": "fca8077b8589dbcc2db1472c9a2823b9be32bd549d13cdf282af33d2f10540f1" + }, + "docs/CONTEXT-SUBSTITUTION.md": { + "mode": "lf-text", + "sha256": "75fe25f8dd14c8fe7475f11071d94ba4f8f6a8ad9afcb2d595e2ac4d08e55586" + }, + "docs/CURVATURE-CONE.md": { + "mode": "lf-text", + "sha256": "2ac9e555d6d4afb5b079542679d2aeeb4a76132a3a0ed7df8720856c731405ce" + }, + "docs/FILTERED-TRANSPORT.md": { + "mode": "lf-text", + "sha256": "abfa6548b223893866094631aed61174575dc1b17bdd60627b2c55e6b9477e4f" + }, + "docs/PR535-README.md": { + "mode": "lf-text", + "sha256": "f7a8e1d4794bb0d349ff73bfdd026796985184fd0839a74ece6fb3b283c90d39" + }, + "docs/PRIVACY-ADAPTATIONS.json": { + "mode": "lf-text", + "sha256": "404b69902eb8afcdf3ab3ece1b5bb7aa9ab5ac1cc8769d5e9062a56bf4a78720" + }, + "docs/PROVENANCE.md": { + "mode": "lf-text", + "sha256": "72e4e91c544d7cea5959d22cd65809a97598fdfa9b031f18183cbbb27bc1c089" + }, + "docs/RESEARCH.md": { + "mode": "lf-text", + "sha256": "e40b8d5cdb2fa96b54c1cbe41a2b028752161c7fa91c3b2cd9d5227362b271a6" + }, + "docs/TRACE-REFINEMENT.md": { + "mode": "lf-text", + "sha256": "e24cd091820f33795aa06f3cc318d61aed6dd17dfc55b0d24d2c3285a1a8ca6a" + }, + "docs/TRACE-SOURCES.json": { + "mode": "lf-text", + "sha256": "cfc61091e4f8e3a22e5749313636b06d570c52161eca34479bcea017052b40c0" + }, + "docs/TRANSPORT-NOTES.md": { + "mode": "lf-text", + "sha256": "aefbe5578b70f4a9dfb73c3f926a1b89acd228175017bb4e3c000b0fa792ff91" + }, + "docs/TRANSPORT-SOURCES.json": { + "mode": "lf-text", + "sha256": "c8aeb9313f2c671a9a8766c249ceb6cffa106dfdab3ab761da8e8c534b115090" + }, + "evidence/ALL-TEXT-PREFLIGHT.json": { + "mode": "lf-text", + "sha256": "e32f7512c82b1e114ae8405ed881bfb26b4ca2eddb261b688eb99458b7c2ef14" + }, + "evidence/BIT-INVOICE.json": { + "mode": "lf-text", + "sha256": "197d75c1a887f7b6a9ae143b478105377b9bc942dd8b72c1581009747b948865" + }, + "evidence/CONSTRUCTION.json": { + "mode": "lf-text", + "sha256": "9659874b176cf8e845fe03b53dc6bed8f139903f8012e785b45d46fe0c618848" + }, + "evidence/CRLF-REPLAY.json": { + "mode": "lf-text", + "sha256": "571b7d4ab93c61a5e16fb8a82750350a16781fbf5c2893b3bb4b4122cd11fbce" + }, + "evidence/CURVATURE.json": { + "mode": "lf-text", + "sha256": "9f210ec5bb25962359d955bcd6574e688f18ffed7627c813509c2e8e7b40a5bd" + }, + "evidence/EXACT-ASSEMBLY.json": { + "mode": "lf-text", + "sha256": "105fea110d57e1091c17e168cb20e879e7b630504d9ed5092467c6e23b38c743" + }, + "evidence/HOSTED-AUDIT.json": { + "mode": "lf-text", + "sha256": "b8f120e82c2c5043c71cfe2cd7951ef3c2d2e8089e72762643495b10bf4d9ee0" + }, + "evidence/INDEPENDENT-REVIEW.json": { + "mode": "lf-text", + "sha256": "0fd05a90efa956d384ce283decb89114ffaaade195f4ef30be2ea016322f4ce3" + }, + "evidence/NATIVE-LEGALITY.json": { + "mode": "lf-text", + "sha256": "775ea56b6d62fca5df5f92de425a3aac287731fd33058d00d68cf5d151f95824" + }, + "evidence/NATIVE-REVIEW.json": { + "mode": "lf-text", + "sha256": "238d411bca4cbc4ab9a765806255b1448def2eb72bce9acd32fd7a1ac96bdd4f" + }, + "evidence/NEUTRAL-TRANSPORT.json": { + "mode": "lf-text", + "sha256": "7bd7e5b8facd38701b0539ac0c828461b16cb38e6d819503f68eab999d5f9b20" + }, + "evidence/NINE-COLUMNS.json": { + "mode": "lf-text", + "sha256": "364eba5a512b05ad6ea89ce8d924bb41b34db630586533c011f54db01b4ac2c6" + }, + "evidence/PARENT-AUDIT.json": { + "mode": "lf-text", + "sha256": "341d665a9ce67e320a587e11565b2b50d5e17bdbb675127c31c224c6ff59466d" + }, + "evidence/REPLAY.json": { + "mode": "lf-text", + "sha256": "3d4c938374867bda9594cc7e75514c2a63c81d23f87fdfb5ab09163c5b9ffd33" + }, + "evidence/RESOURCE-RESULT.json": { + "mode": "lf-text", + "sha256": "fae38e1bb40b8d0fe0e2bcf98386a654fd70703ac54ee77c7a6778062901f6a2" + }, + "evidence/STATIC44-SCALAR-AUDIT.json": { + "mode": "lf-text", + "sha256": "abd85dd0b7dc65f43f4cba09e1a919db330c4f7dc79e0f88d50bb679bf8a4c70" + }, + "evidence/TRANSPORT-CONTROLS.json": { + "mode": "lf-text", + "sha256": "571659f55a00caae749bd4e54d7739e9d779832a481e49eeab0565299e561114" + }, + "evidence/WORD.json.gz": { + "mode": "raw", + "sha256": "db5cd7ab49e2e58a2924a2a9e68ee69d8165b4d5c008b6f546577f4791019dca" + }, + "EXPECTED.json": { + "mode": "lf-text", + "sha256": "354268fcffbf27c1e93006e9db648a7415ea8ecec8a8b77e6ce73eb3844f0294" + }, + "inputs/NINE-GEOMETRY.json.gz": { + "mode": "raw", + "sha256": "8a04c048a6ad87f8004fc650263dcac6de7d815e6f00eb93b1b36c1623f34a43" + }, + "inputs/PR510-EXPECTED.json": { + "mode": "lf-text", + "sha256": "883f7a1a84f31d9e4430e348bc8d9c1ec10210b206ff602dbe126349056af13d" + }, + "inputs/PR535-EXACT-ASSEMBLY.json": { + "mode": "lf-text", + "sha256": "246f082c286170d61f0aff3cbc4e4162852e5b162ea67cee274b280c04c4e564" + }, + "inputs/PR535-HOSTED.json": { + "mode": "lf-text", + "sha256": "21c7aff3bfffefbd5a5f41be0ba3b1f9317528137858536a6473953692592b96" + }, + "inputs/PR535-OWNERS-AND-PROFILE.json": { + "mode": "lf-text", + "sha256": "86dd8c1851ec818628dee96ceafbfa31611d1a80eb4fd8084b207607795895ba" + }, + "inputs/PR535-PREFIX-AND-INVOICE.json": { + "mode": "lf-text", + "sha256": "c79683443afa9a974fe8a8fd009f8efa8358d3f5d8b3972ae058b07869166172" + }, + "inputs/STATIC44-RECIPE.json": { + "mode": "lf-text", + "sha256": "8735ac9beadff3edcb4a4df8dae174415e0f83d9b4df8556c33ba7fd777505fa" + }, + "inputs/UPSTREAM-PINS.json": { + "mode": "lf-text", + "sha256": "1a7f0ea4c0916e3d95cc976342a1e8fc9b02d925af9295d81c4af7b0a4ab0255" + }, + "README.md": { + "mode": "lf-text", + "sha256": "046439afa0967319aec79e71f7b1cf7a9a5da084bbc1b584d5000b69c9c2dad9" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": { + "mode": "lf-text", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": { + "mode": "lf-text", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/checkers/gram_frames.py": { + "mode": "lf-text", + "sha256": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": { + "mode": "lf-text", + "sha256": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": { + "mode": "lf-text", + "sha256": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/export_records.py": { + "mode": "lf-text", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/independent/checkword.py": { + "mode": "lf-text", + "sha256": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/independent/interface.py": { + "mode": "lf-text", + "sha256": "2c63a039f97e3a11ce5a6b83302d4f5beda160c1db14164a5a9b0855aeb19d3c" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/independent/mutate.py": { + "mode": "lf-text", + "sha256": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/independent/mutate_mut.py": { + "mode": "lf-text", + "sha256": "3b002c19a5dcca76a5594f2a30fac7c01d2b45fc96b3e7cfbfd8b720f5ffb4e8" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/independent/relax.py": { + "mode": "lf-text", + "sha256": "d6e9f58de3fa41f538516b6227c249d61fb30f0f6843027cc8a07a1a372fa6b6" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/mutate_records.py": { + "mode": "lf-text", + "sha256": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/mutate_records_mut.py": { + "mode": "lf-text", + "sha256": "a9e085ec60d5657cd5d77832e3d95004e81b9f4f249d9e0fc95e345366cb2d2e" + }, + "vendor/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py": { + "mode": "lf-text", + "sha256": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a" + }, + "vendor/e8-bit-carrier-skeleton/code/cited.py": { + "mode": "lf-text", + "sha256": "a4c2dd4755f2a45ceda327b36d9ee400c2804893000626ca8ff3f6ee296fd842" + }, + "vendor/e8-bit-carrier-skeleton/code/eleven/adapt.py": { + "mode": "lf-text", + "sha256": "d8a8c13b484d985f0133a5d06de4a78b8477314f922b9f693ba73640b7184d6b" + }, + "vendor/e8-bit-carrier-skeleton/code/eleven/assemble.py": { + "mode": "lf-text", + "sha256": "c47889a606701ae592374dd82a13cee8c5a4e8449b7facfdad2d90563a30a18c" + }, + "vendor/e8-bit-carrier-skeleton/code/eleven/audit.py": { + "mode": "lf-text", + "sha256": "5ad832830c19ec6c904d1b64480f6b1e71c5673fdd38d487d17e179b1d197c09" + }, + "vendor/e8-bit-carrier-skeleton/code/eleven/emit.py": { + "mode": "lf-text", + "sha256": "b0b25955875625ed63f82690f83aef976e3e9a978ae6620b23a23fc1207acd46" + }, + "vendor/e8-bit-carrier-skeleton/code/eleven/local_audit.py": { + "mode": "lf-text", + "sha256": "95275473d7f9811011bda760dd0f04de5169c2a6922456dc9a5725a5d671f941" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/assemble.py": { + "mode": "lf-text", + "sha256": "abb60c35e448e0f94073f38a0352d11249aaf7bb8dbd7352414ae60a1d2b79c3" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/audit.py": { + "mode": "lf-text", + "sha256": "d28062127a9b0d3866a3b79aad98a307233b20ebdb94cfb9f197d726b82ffea5" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/emit.py": { + "mode": "lf-text", + "sha256": "98d77cefbc3a76f9f10bd7df3a2590ab88b411f6afe77b5f8d73f1602eb2bef3" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/code/local_audit.py": { + "mode": "lf-text", + "sha256": "23eda3fe3d774e7f2dbf4dbdd4ff90d69ae7d1762ff95c8629cdc7667aa3fe71" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/hosting.json": { + "mode": "lf-text", + "sha256": "765382d4fefd594e94c8c5826ec6300422ce9f79c816d7f7323ef85e99320f28" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/residual-isometries.json": { + "mode": "lf-text", + "sha256": "750221cc66badd0ed0a74e7aad2d59f91f89c107370af21c6d929fbdd4a08a9f" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r715-whole-hosted/data/word.json.gz": { + "mode": "raw", + "sha256": "b2af02f593cd161bea64e6cd793508386914136be519f80726c071697379d5a9" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/bank_routes.py": { + "mode": "lf-text", + "sha256": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/e8core.py": { + "mode": "lf-text", + "sha256": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/base_two_moment.py": { + "mode": "lf-text", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/moment.py": { + "mode": "lf-text", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines/outer.py": { + "mode": "lf-text", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/tile_m.py": { + "mode": "lf-text", + "sha256": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/residual-isometries.json": { + "mode": "lf-text", + "sha256": "e12ed7ddd13cee101ba74a083b54665fd64d0b122b0bad5b83d817dcc8bae9d8" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/data/word.json.gz": { + "mode": "raw", + "sha256": "d8d6d3d3f336720302bc40b3c1504fe3c3583a7a8d707bb9bd7b21f85e5e69c6" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/idle-axis-hosting/hosting_core.py": { + "mode": "lf-text", + "sha256": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/emit.py": { + "mode": "lf-text", + "sha256": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/geometry.py": { + "mode": "lf-text", + "sha256": "9554182d67e434ea84b4430f909a2c400abc755d8487b51454a8e6968e62859d" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/code/row_bound.py": { + "mode": "lf-text", + "sha256": "de4a9b9cd797e1a05da56f62cfe725c8728cea3a4aa031b7d1b0a68f869760d6" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-eleven/data/selection.json": { + "mode": "lf-text", + "sha256": "52dbbb68e8c147690d15eaa1d952df05d074b0c121885a4159d9f6732f391872" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/code/emit.py": { + "mode": "lf-text", + "sha256": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/residual-isometries.json": { + "mode": "lf-text", + "sha256": "b23fda74a7979179e8fd83ee9870c1e232442cc90c05077adaabfe31d050d1e4" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/selection.json": { + "mode": "lf-text", + "sha256": "4d9c2cf6a3d31a6faa287731e0721cb16601b0bc5c1a186b9645bfb5760ce8db" + }, + "vendor/e8-bit-carrier-skeleton/code/hub/r740-hosted-rank149/data/word.json.gz": { + "mode": "raw", + "sha256": "41626789888ee070e1b435fa380b10ab9b88e3cf7d8d8e166ecef17269bbcf47" + }, + "vendor/e8-bit-carrier-skeleton/code/nine/geometry.py": { + "mode": "lf-text", + "sha256": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca" + }, + "vendor/e8-bit-carrier-skeleton/code/pricing/base_two_moment.py": { + "mode": "lf-text", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + "vendor/e8-bit-carrier-skeleton/code/pricing/moment.py": { + "mode": "lf-text", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + "vendor/e8-bit-carrier-skeleton/code/pricing/outer.py": { + "mode": "lf-text", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "vendor/e8-bit-carrier-skeleton/code/pricing/prime_witnesses.py": { + "mode": "lf-text", + "sha256": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab" + }, + "vendor/e8-bit-carrier-skeleton/code/provenance.py": { + "mode": "lf-text", + "sha256": "e28fd87d0e34a6f6f6f1fddb6c4891deac220662c954de855d7aa5a7f9cceca4" + }, + "vendor/e8-bit-carrier-skeleton/code/skeleton/e8.py": { + "mode": "lf-text", + "sha256": "721d859a6517d665ca84d03ef89668da3aae7433ffb0ee47faf37f2aeb85450e" + }, + "vendor/e8-bit-carrier-skeleton/code/skeleton/gen.py": { + "mode": "lf-text", + "sha256": "7cdcf48078ed4beacd2e240aa8145e4aa6984558748d07659cb1b252786e073a" + }, + "vendor/e8-bit-carrier-skeleton/code/skeleton/geom.py": { + "mode": "lf-text", + "sha256": "bb356568fa05e7bfd5fcd9012903611cf742729a99b4dc3a13685355b2678ae3" + }, + "vendor/e8-bit-carrier-skeleton/code/skeleton/wordkit.py": { + "mode": "lf-text", + "sha256": "2b6c12d96f24a4e81f2c807827c2b74cf80037367fc8034e8c871dd5ce008351" + }, + "vendor/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": { + "mode": "raw", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "vendor/e8-bit-carrier-skeleton/data/bit/bitE8mut-r489.json.gz": { + "mode": "raw", + "sha256": "835eb96e147740fc7454f8cfb3dbd34ae89524b1dbd89a61e9288eae8ab6a5b9" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr448/EXPECTED.json": { + "mode": "lf-text", + "sha256": "18b42250c3faf6f0df76fcab6c3a483582192ad7bb09cb1985f4b0bb91d67024" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr458/EXPECTED.json": { + "mode": "lf-text", + "sha256": "a4312cb0c53c2066a28b683a971a41e7d76c5f6d828a96481c3ae7b3c01bb2f3" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr471/EXPECTED.json": { + "mode": "lf-text", + "sha256": "a7867a0ed4e71ea8dddf77265a289eb3cd4a4dca9dfaca50ab4a55fe75c3a3fa" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr473/EXPECTED.json": { + "mode": "lf-text", + "sha256": "70e515f0a5a2f9508cd030d35a99f90981a6eccc027c9ad5a3c77f5860310910" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr478/EXPECTED.json": { + "mode": "lf-text", + "sha256": "17460cee9d36ba006338e014c99bf4e67802cbb8ed2c9e07063ba0bd07c35ab1" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr483/EXPECTED.json": { + "mode": "lf-text", + "sha256": "c706ba18fdf2614ecaad8bcd935dd341a0ab5cabd267a1ba4abf78c299e1d506" + }, + "vendor/e8-bit-carrier-skeleton/data/complex/pr484/EXPECTED.json": { + "mode": "lf-text", + "sha256": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be" + }, + "vendor/e8-bit-carrier-skeleton/data/complex-b.json": { + "mode": "lf-text", + "sha256": "69ebf33805b5d2590750628eec6d755b62cf494a987e99114fa997cd146811c9" + }, + "vendor/e8-bit-carrier-skeleton/data/eleven/hosting.json": { + "mode": "lf-text", + "sha256": "61f790657c465d16d3455f48f90f816797b9ea08bf02dbd0c90d2cf41836257e" + }, + "vendor/e8-bit-carrier-skeleton/data/eleven/residual-isometries.json": { + "mode": "lf-text", + "sha256": "0fa5b353a0321af2ce4e2045db1d4c2d6418a11663894e2afcdb1eaa1984bddc" + }, + "vendor/e8-bit-carrier-skeleton/data/skeleton/d4part-pairs.json": { + "mode": "lf-text", + "sha256": "d69ffe3326140bc541b8f1639e02db43a5835ab8ca02cc742b5bee2bf2ef1ba9" + }, + "vendor/e8-bit-carrier-skeleton/data/skeleton/plan-skB.json": { + "mode": "lf-text", + "sha256": "f6162bb4d8092bc233700fa7ebc6a0d79f2893135aee18e998369044abb3f44b" + }, + "vendor/e8-bit-carrier-skeleton/discovery/d4part.py": { + "mode": "lf-text", + "sha256": "a64927c340a4772ce0682b349e0c90c80d1a766000ccf397fb41b36a31929179" + }, + "vendor/e8-bit-carrier-skeleton/discovery/host_select.py": { + "mode": "lf-text", + "sha256": "2aaaac18e083d289d4341e734c32571c89c51fefba04b388d407c7372b906dc7" + }, + "vendor/e8-bit-carrier-skeleton/discovery/plan.py": { + "mode": "lf-text", + "sha256": "40e8dea1b4b71c5afd5993625f57bcac089dd2f72dfbc4dbc23ce917e5a61010" + }, + "vendor/e8-bit-carrier-skeleton/discovery/README.md": { + "mode": "lf-text", + "sha256": "b09aa45d5651720e10326cde559c863ba3ea45fe2fb6b4aaa3bfaa66a8fcf69f" + }, + "vendor/e8-bit-carrier-skeleton/EXPECTED.json": { + "mode": "lf-text", + "sha256": "3494ba83280cc86548fe0cc6695c50d23e6b6ffca85aeb1a33337c1196e280cb" + }, + "vendor/e8-bit-carrier-skeleton/LICENSE": { + "mode": "lf-text", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "vendor/e8-bit-carrier-skeleton/MANIFEST.sha256": { + "mode": "lf-text", + "sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297" + }, + "vendor/e8-bit-carrier-skeleton/NOTICE.md": { + "mode": "lf-text", + "sha256": "58a67a49403ff74e4bb8bd0a2962d29e6181bb9f7e14d80570da52ec0dcfb5fc" + }, + "vendor/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": { + "mode": "lf-text", + "sha256": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + }, + "vendor/e8-bit-carrier-skeleton/README.md": { + "mode": "lf-text", + "sha256": "0076f8c5deff6a44c7cfb793b5e6d109da49f0a952401a99d1e32f230bb16aab" + }, + "vendor/e8-bit-carrier-skeleton/requirements.txt": { + "mode": "lf-text", + "sha256": "6023d480f929cdfa4e2f35e361eea003451cd6695af806935a32038b0115abb5" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr370.json": { + "mode": "lf-text", + "sha256": "03de1d341196cfa8cf1d39f3cc8648b25bb5f39c3c602a728cfbd089e8253ac0" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr381.json": { + "mode": "lf-text", + "sha256": "16b1977240ca9acb58fa64572fb4231a423bc10bbf3e7bb30f1c8201fe369ba5" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr386.json": { + "mode": "lf-text", + "sha256": "87c659ba932525631a40be14dca28a6a2efade8641f23bb08d6e1567fc991131" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr436.json": { + "mode": "lf-text", + "sha256": "4a4f99f5bdb7530a0dcf9433f7f02afbf2abf908e718f7c63ffa5503d4f49693" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr445.json": { + "mode": "lf-text", + "sha256": "e6f4a272442bb71ef68aaa3545b271236f9c99297e444fa01c62b0b5fb6a170f" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr448.json": { + "mode": "lf-text", + "sha256": "c771fa9be492408a78d6d970c839e68c4dfd1b66f4f4a4748e3d12726a43cf27" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr451.json": { + "mode": "lf-text", + "sha256": "a639956eec858341987a815b7464ef472505300db754b5f9ac012dd01d18c8df" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr458.json": { + "mode": "lf-text", + "sha256": "cbdea984a46ab5de354b95e73fd76c1918fdc6676c658398a552772c4dc3dcaf" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr471.json": { + "mode": "lf-text", + "sha256": "273a4bbbe3e060f44cd817207d1e655118c108b51684e361ef7c3e3a97610c97" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr472.json": { + "mode": "lf-text", + "sha256": "6753bcf50c91806b75dd4dbe3963a79699a614d0dab8ce32b261cc3e76b288b1" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr473.json": { + "mode": "lf-text", + "sha256": "2515c4f23dfa22a21913d92597669770f7f44c2a5b3ef069ef68a0c89779a656" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr478.json": { + "mode": "lf-text", + "sha256": "8fda6b549ec87bbaf5ef3f36f10cdd7ffd5c687a9a7210d295b368bb65711159" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr483.json": { + "mode": "lf-text", + "sha256": "d7b3cb50c5d1b07f0e559c9a983859fe21e15ad625bd93cfa15d81497b0aac47" + }, + "vendor/e8-bit-carrier-skeleton/SOURCE-pr484.json": { + "mode": "lf-text", + "sha256": "b92f43fbcba3921a1aa37bcb9f05cf5fa612ff708785e05512438a6317bf0867" + }, + "vendor/e8-bit-carrier-skeleton/verify.sh": { + "mode": "lf-text", + "sha256": "0f9248aa3611dfe2b5d59dbe992c6f7d21a0cc4f1de2b5ed05a6110191191224" + }, + "vendor/e8-r480-dead-totals/code/adapt.py": { + "mode": "lf-text", + "sha256": "04ec15262595e502796efc1f100f1efd4f28585add48377af1bda702a12c0e40" + }, + "vendor/e8-r480-dead-totals/data/bitE8mut-r480.json.gz": { + "mode": "raw", + "sha256": "92e399e9a486b55229b5624632ac54f800dd9e022f2aee97f1e5f264bbc0ef5c" + }, + "vendor/e8-r480-dead-totals/data/hosting-r480.json": { + "mode": "lf-text", + "sha256": "29d55f5389a6bd7650e083b8318e725b505d8a6460a7afb4ddb08824675b6827" + }, + "vendor/e8-r480-dead-totals/EXPECTED.json": { + "mode": "lf-text", + "sha256": "5e4a6b141ffd110a539f3be05be1bd249dc5ecec898cdd838642c71f9c42ac9b" + }, + "vendor/e8-r480-dead-totals/LICENSE": { + "mode": "lf-text", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "vendor/e8-r480-dead-totals/MANIFEST.json": { + "mode": "lf-text", + "sha256": "5cf65e9dd0af2de68498c360bd118eb38e926fd9c7da1bc6bb054ee9ec64e262" + }, + "vendor/e8-r480-dead-totals/NOTICE.md": { + "mode": "lf-text", + "sha256": "90e0b76e6f7c15bda8d854ec5bc6e07e4553ec1f73c86b17c35bd77b0abc4438" + }, + "vendor/e8-r480-dead-totals/README.md": { + "mode": "lf-text", + "sha256": "60750f7b4706bc8fcccb19b2650e75bde58b8cde9a38defe536f210a0de6941f" + }, + "vendor/e8-r480-dead-totals/verify.py": { + "mode": "lf-text", + "sha256": "c28ad846dcb012d270c0bf4f9e998696d319c20bfaedf2963fd5138b3369fd66" + }, + "vendor/e8-r480-nine-stage/code/adapt.py": { + "mode": "lf-text", + "sha256": "27b6b77cc4ebf439f9019e63a22dedc1ef72ee65fe120aad3d17316b1df06d7b" + }, + "vendor/e8-r480-nine-stage/code/assemble9.py": { + "mode": "lf-text", + "sha256": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe" + }, + "vendor/e8-r480-nine-stage/code/findings/flowlp2.py": { + "mode": "lf-text", + "sha256": "2e778aa9adaee190f9b72a6dac45b5fdeac04110baa00cdc1b0ff49e2ae84554" + }, + "vendor/e8-r480-nine-stage/code/findings/levels.py": { + "mode": "lf-text", + "sha256": "366a56e07b61df63b46eb50dba4843e9416a63eb993106f1d139742d575767db" + }, + "vendor/e8-r480-nine-stage/code/findings/piv0.py": { + "mode": "lf-text", + "sha256": "b6dea0162404d7a54d1e20c4b14720f00239eb4512187e09e6eb8e075887a00e" + }, + "vendor/e8-r480-nine-stage/data/selection9-r480.json": { + "mode": "lf-text", + "sha256": "8176db518bed23ea8121543bfb18085ec6633064142ba40ac5db00f63b06553d" + }, + "vendor/e8-r480-nine-stage/EXPECTED.json": { + "mode": "lf-text", + "sha256": "883f7a1a84f31d9e4430e348bc8d9c1ec10210b206ff602dbe126349056af13d" + }, + "vendor/e8-r480-nine-stage/LICENSE": { + "mode": "lf-text", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "vendor/e8-r480-nine-stage/MANIFEST.json": { + "mode": "lf-text", + "sha256": "4da5a1b9b3249368cb9fcca792b0771775ee7f21ca58614ddc6bb974b94733c4" + }, + "vendor/e8-r480-nine-stage/NOTICE.md": { + "mode": "lf-text", + "sha256": "f3e97a9876a4d79af9260acc95df9e6b88e46f761a6c4b7a4e75e959468cf47e" + }, + "vendor/e8-r480-nine-stage/README.md": { + "mode": "lf-text", + "sha256": "14ba6d703dde9429c82c546199affe855c147ccfd5012fc13da9f18cdf0b5dda" + }, + "vendor/e8-r480-nine-stage/SOURCE.json": { + "mode": "lf-text", + "sha256": "c58978211d35c902e8dcf65f94220060959eae97d58e68f245d566bfb33fdef7" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py": { + "mode": "lf-text", + "sha256": "57e558c80a2fea6e291587b04afd76dfaee3550729997798b61f33daf90b8ec9" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_parent_k.py": { + "mode": "lf-text", + "sha256": "374e1d983589463bbfa06b6e9f2ffafb9d2c14acf97b1f858593a3cef90e93d2" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/bank_routes_k.py": { + "mode": "lf-text", + "sha256": "ea678a7befda10c6f1b9dd38a36fe1437c6468472bd649f60b9f01522047e0bf" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/emit_k.py": { + "mode": "lf-text", + "sha256": "298b16c3d4f58a468ad1a64564c8500cb281414a3f3c0428fd467908eeb4a4b4" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": { + "mode": "lf-text", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/hosting_k.py": { + "mode": "lf-text", + "sha256": "081c3b95b18d900d97ce82af64fb428f085b6adc6d8ca93ea920797dad7eb81e" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/bank_routes.py": { + "mode": "lf-text", + "sha256": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/config.py": { + "mode": "lf-text", + "sha256": "283d7fad45155ee91e704d63ec947cf4a60aeff5cc43510bc0e835f7da7d8767" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/e8core.py": { + "mode": "lf-text", + "sha256": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/base_two_moment.py": { + "mode": "lf-text", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/moment.py": { + "mode": "lf-text", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/outer.py": { + "mode": "lf-text", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "vendor/e8-r480-nine-stage/vendor/e8-r740-replica32/code/tile_m.py": { + "mode": "lf-text", + "sha256": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd" + }, + "vendor/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py": { + "mode": "lf-text", + "sha256": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3" + }, + "vendor/e8-r480-nine-stage/verify.py": { + "mode": "lf-text", + "sha256": "28c369decf805aa5ea9a1e7c9d8b373a814f57cea8098ab9ed31c3fa6d3af86c" + }, + "verify.py": { + "mode": "lf-text", + "sha256": "a9dad1d31cb5a0bf88b3fb14955773db740d52fe95a48fa08450f20b8c19ec94" + } + } +} diff --git a/research/trace-curvature-preload/README.md b/research/trace-curvature-preload/README.md new file mode 100644 index 0000000000..71ceaf5958 --- /dev/null +++ b/research/trace-curvature-preload/README.md @@ -0,0 +1,42 @@ +# Trace refinement and curvature-certified bit supplier + +Conditional kappa = 0.001587212454640692 (exactly 396803113660173/250000000000000000). + +This improves the frozen PR535 claim of 0.001584931111785787 by 0.143940%. It combines a newly constructed bit word with the unchanged, pinned PR535 complex supplier. The public snapshot ends at PR536. No claim is made about submissions appearing later. + +## Mechanism + +The new construction factors 60 two-source helper additions, moves one summand to an earlier commuting position, and chooses its rank-one common frame there. It then regenerates literal inverse cleanup. The full dirty-register map is unchanged. The paid local delta is60(e1-2e2+e3); at nine stages and 32 replicas it becomes17280(e1-2e2+e3). The same 480 full-width-eight residuals fit the same literal owner selection. No gains are added numerically. + +The complete new bit profile is {1:362880,2:395520,3:17280,4:67200,6:49920,7:23040,8:2592}. Live stock 30720, physical stock 30729 and deficit 9984 are unchanged. Exact interval engines give bit c=0.001589735702947998836661; unchanged PR535 complex b=0.001589991533606044174031. The bit supplier still binds. + +## Four reusable mathematical arguments + +1. Frame-sensitive trace refinement: optimize event order and legal frame assignment jointly, rather than restricting to one scalar ordering. See docs/TRACE-REFINEMENT.md. +2. Context substitution: replace any collection of complete calls with endpoint/width-equivalent providers and transport exact resource deltas through the controller. See docs/CONTEXT-SUBSTITUTION.md. +3. Curvature-cone calculus: a finite nonnegative second-difference certificate characterizes improvement for every discrete concave cost; here it proves improvement for the entire continuum of recurrence exponents. See docs/CURVATURE-CONE.md. +4. Filtered response and version transport: reusable-donor elimination with correct execution order, and exact D A^-1 compensation at a changed cut. See docs/FILTERED-TRANSPORT.md. + +These arguments are sufficient theorems with explicit proofs. Elementary transvection, concavity and change-of-basis facts are established mathematics; no global novelty or new Lean certification is claimed. The new numerical application is the60-cell construction. The fourth argument also has a neutral 720-column bit example and a locally checked40-to44-pivot complex appendix; neither is counted as an additional final kappa gain. + +## Replay + +Requirements: Python 3.11+ with numpy and sympy, a C++17 compiler, and genuine Boost headers. The default Linux Boost include directory is /usr/include. No network, optimizer, GPU or Lean installation is needed. + + python -B verify.py --work /absolute/new/output --cxx c++ --boost-include /usr/include + +On Windows pass the actual compiler and include directory through --cxx and --boost-include. Output must be a new directory outside this package. Do not use Python -O. Dependencies are vendored with their attribution. Only the changed bit word is rebuilt through native and global checks; the unchanged PR535 complex realization is a cited dependency whose exact profile is repriced. + +The main replay reconstructs the source; checks 720 local columns, rational frame incidence, native five-stage 960 and nine-stage 1440 columns; rejects 18 bridge, 6 structural and 3 mutable-source controls; checks all 672 frame Grams; emits and audits 10,631,808 global events, all 138240 whole-owner residuals and 17 parent + 16 hosting mutations; recomputes prefix/invoice; proves the curvature certificate; reprices both suppliers with both exact interval engines; and checks 47 strict outer inequalities and four invalid-parameter controls. It also replays the explicitly local-only appendix. + +Finite bills: global bit prefix 193 bits (charged 256), two-level coefficient 425 bits (charged 512), row 18355<20161, depth 2. The package's manifest normalizes LF text to tolerate Windows Git checkouts. The new bit-word and geometry gzip files fix level 9, mtime 0 and OS 255. Inherited generated templates are identified by their uncompressed contents. Binary artifacts are hashed exactly. Timing is not a mathematical identity field. + +## Scope + +This is a conditional finite-witness improvement under the retained all-size compiler, common-label/mutable-basis, whole-call hosting, restored-work, precision/tape and analytic-transfer contracts. It is not an unconditional sub-n-log-n integer multiplication theorem. The exact PR535 physical complex source is not independently reconstructed here. Its owner, invoice and assembly receipts are pinned as cited inputs. All changed-bit physical checks are fresh. + +## Provenance + +Direct dependencies: PR510 nine-stage R480 context, PR503 R480 word, PR493 E8 skeleton and native checks; PR535 complex supplier. The inherited chain includes PR463 variable-stage emission, PR442/444 whole-residual hosting, PR386 nine-stage geometry, and the attributed moment/outer engines. PR531 supplies the504-helper complex foundation; PR533/534/536 informed the separate response/frame comparison and local appendix. They are not all numerical contributors to the final bound. + +See docs/PROVENANCE.md for links and exact snapshot pins, docs/RESEARCH.md for bounded alternatives, and appendix/static44 for the reproducible local headroom witness. diff --git a/research/trace-curvature-preload/appendix/static44/LICENSE b/research/trace-curvature-preload/appendix/static44/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/trace-curvature-preload/appendix/static44/META-SOURCES.json b/research/trace-curvature-preload/appendix/static44/META-SOURCES.json new file mode 100644 index 0000000000..8cbd32f8bd --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/META-SOURCES.json @@ -0,0 +1,24 @@ +{ + "scope": "Actual source statements inspected as structural analogues; no Lean compilation or source theorem directly certifies the new circuit.", + "sources": [ + { + "relative_source": "Mathlib/LinearAlgebra/Matrix/Transvection.lean", + "sha256": "c8c60dfbda7a09877a884aa2c7ce385f24f5370bb2a456cc20aae872c7dd41ef", + "statements": [ + "mul_transvection_apply_same", + "mul_transvection_apply_of_ne", + "TransvectionStruct.reverse_inv_prod_mul_prod", + "TransvectionStruct.prod_mul_reverse_inv_prod" + ] + }, + { + "relative_source": "OAI/GroupTheory/Congruence/Elementary.lean", + "sha256": "dde2c70e97566d678e96c126476314c994ce4b68858b9aa6c484b9820e950bd8", + "statements": [ + "OAI.CoboundaryExpanders.Elementary.E_mul_apply", + "OAI.CoboundaryExpanders.Elementary.upper_E_mul", + "OAI.CoboundaryExpanders.Elementary.clear_step" + ] + } + ] +} diff --git a/research/trace-curvature-preload/appendix/static44/NOTICE-upstream.md b/research/trace-curvature-preload/appendix/static44/NOTICE-upstream.md new file mode 100644 index 0000000000..f42e0eed85 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/NOTICE-upstream.md @@ -0,0 +1,70 @@ +# Attribution and dependency notice + +Package: **`integer_mult_round21_rank4_delta`**. + +Copyright 2026 icekylinx. Local review and packaging used OpenAI Codex. + +## New work + +Prepared by **icekylinx with GPT-6 Astra assistance**. The new contribution is +the post-center timing and ordered composition of dirty gauges with rank-four +response kernels, including the 14 disjoint M-helper groups, explicit scalar +word, frame and cleanup treatment, independent local argument, physical global +integration, paid accounting, and combined conditional κ assembly. + +The same helper can first serve its own gauge and then donate to a larger +kernel because compensation occurs before the new pivot dirt is injected. +This ordering, its actual frame nesting, and its global use are the substantive +delta. Earlier gauge/kernel primitives and the SAME504 scalar construction +retain their original authorship. + +## Baseline + +[PR531](https://github.com/CrocSwap/integer-mult-bounds/pull/531), by icekylinx +with the disclosed GPT-6 Astra assistance, supplies the SAME504 construction +and the baseline package `research/direct-delivery504-global`. The final +baseline head is `e07a8a3f9f79c22113398a0c5dbbc7601f489b3e`; the scientific +files used here match the original Round20 pins. + +**The original PR531 NOTICE is retained separately and remains applicable.** +That notice records the scalar, geometry, controller, phase, wrapper, hosting, +and analytic ancestry. This short incremental notice does not replace it. + +In particular, DreamingOfClouds's PR484 response/kernel implementation and its +predecessors retain their source notices. Zhihao Chen's PR425 mutable-basis +lemma, the PR425/433/514 scalar lineage, and the previously credited source +and delivery contributions remain attributed through PR531's notice. + +## Adopted bit supplier + +[PR510](https://github.com/CrocSwap/integer-mult-bounds/pull/510), pinned to +`64edee18af02aab0c1696b677a0287dd0146381b`, is by **DreamingOfClouds with +Claude Opus 5.5 assistance via Claude Code**, as disclosed by that package. +Its R480 nine-stage bit endpoint is adopted as a cited conditional dependency. +It is not a new bit-side research result of this delta, and no cold replay +of that full bit pipeline was performed here. + +**The original PR510 NOTICE is retained separately and remains applicable.** +Its ancestry includes eumemic's PR493 carrier-skeleton word; PR503's R480 +dead-total change; chafreaky's PR443/444 replication pipeline; DaysSky's PR442 +whole-residual hosting and PR381 column checker; Zhihao Chen's PR386 geometry; +DreamingOfClouds's PR315 moment engines and pipeline adaptations; and Dylan +Crow's PR370 framework, with the assistance disclosures in those sources. + +The present PR510 mutable-source carryover exposition is by icekylinx with +GPT-6 Astra assistance. It expands the role-independent common-label argument +already present in PR472 and the mutable-basis lemma of PR425; it does not +claim those underlying ideas as new. + +## Comparison, evidence, and licenses + +PR493 is also retained as the former-bit-supplier control. PR533 is used only +for numerical comparison. A cited rate, reused certificate, or prior notice +does not imply a fresh replay in this package; the README states the completed +validation scope. + +Original source headers, notices, licenses, and pinned provenance remain in +force. This incremental notice does not relicense upstream material. New +Python research/audit files carry the Apache-2.0 notice stated in their source +headers. All reported bounds remain conditional on the listed inherited +interfaces. diff --git a/research/trace-curvature-preload/appendix/static44/PROOF.md b/research/trace-curvature-preload/appendix/static44/PROOF.md new file mode 100644 index 0000000000..1d43cf78f4 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/PROOF.md @@ -0,0 +1,61 @@ +# Filtered elimination and state-version transport + +These are sufficient compilation theorems. They do not assert that a desired low-cost factorization exists, that the searched family is complete, or that scalar rank alone determines the recurrence exponent. Every elementary operation and changed frame transition remains part of the actual invoice. + +## Theorem 1: elimination with reusable donors and reversed execution + +Let C be the observed target-response matrix on helper coordinates over a field. Suppose we have stages j=1,...,k. At stage j choose new pivots P_j, donor indices D_j disjoint from P_j, and relations between the current response columns + + C_j[:,p] = sum_{d in D_j} q[d,p] C_j[:,d]. + +No previously eliminated pivot may be used again as a new pivot or a donor. A donor may become a pivot at a later stage. Form U_j from the commuting shears d <- d-q[d,p]p. Then right multiplication by U_j changes only the pivot columns, setting them to zero, and leaves all other columns unchanged. Thus, by induction, C U_1 ... U_k has zero columns at every selected pivot, including pivots which previously served as donors. The products are invertible, with explicit inverse obtained by reversing the elementary operations and their signs. + +The actual physical prefix must execute the stage blocks in order k,...,1, since column states are multiplied on the left while the response map is on the right. This reversal is essential: merely concatenating algebraic discovery order is generally wrong. The numerical relations at later stages can be evaluated on the original remaining columns because only already-eliminated columns changed. + +For each helper, collect the frames of every stage touching it in physical execution order, followed by its original first-touch frame. Require this list to be nested. A pivot starts at its own elimination frame; other helpers start at their specified old entrance. Require all initial frames to be contained in their first physical touch. These are finite sufficient geometric tests. Regenerate the inverse background cleanup. If the background subsystem never reads output target registers, this cleanup restores every background coordinate for arbitrary initial dirt. Zero response of every warm pivot ensures its dirt never needs a forbidden zero-frame output compensation. Existing gauges may be retained only under explicitly checked separation or a proved read-before-injection order, not by ignoring overlap. + +The exact local resource signature is obtained register by register from the successive dimension differences in this list. Repeated equal frames cost zero; every positive difference contributes one child of that rank. A pivot's residual width decreases by its entrance dimension. This chain invoice is valid even when supports overlap and the simple sum of disjoint component invoices is not. Full wrapper and physical owner costs remain separate. + +Proof of the response assertion is the elementary column-update identity above and induction. Proof of geometric legality is exactly the nested-chain test at every instruction. Proof of restoration is inversion of the explicitly changed background product. There is no existential oracle in the construction. + +## Concrete application: the PR535 static quotient presentation + +The frozen PR535 construction has 40 static rank-one pivots, 112 post-center gauges and 56 rank-four post-center pivots. We leave its post-center construction unchanged and replace only the static response presentation. The new selection uses six line classes: + +| Frame | Pivots | Active donor list size | +| --- | ---: | ---: | +| 96 | 8 | 8 | +| 102 | 8 | 8 | +| 120 | 8 | 8 | +| 126 | 8 | 8 | +| 480 | 10 | 14 | +| 486 | 2 | 6 | + +This gives 44 static pivots. The actual scalar word loses exactly four rank-one children; all other local rank multiplicities remain identical. Residual inventory changes from 56 width-five, 152 width-eight, 296 width-nine to 56 width-five, 156 width-eight, 292 width-nine. + +This witness is a depth-one special case of the staged theorem: its selected supports do not need donor-to-pivot reuse. The broader nested search generated it, but we do not attribute its numerical change to deeper nesting. The gain here comes from choosing a different joint response presentation across line classes, rather than maximizing each public component in isolation. + +`build_static44_portable.py` recomputes every selected rational relation, retains the original downstream scalar operations and frame labels, regenerates cleanup, and checks source/result semantic hashes. It checks the actual nested frames, complete local histogram and dyadic scalar contract. `STATIC44-SCALAR-AUDIT.json` independently checks every one of the 728 formal columns in both orientations and rejects all 44 omitted-static-correction controls with the correct compensation held fixed. Arbitrary helper dirt is included among these columns. This is a checked local construction, not a claimed globally hosted bound. The final package may continue to use unchanged PR535 if the bit supplier still binds. + +## Theorem 2: compensation transport along exact register versions + +Split state into background X and outputs Y. Let an invertible background prefix act by X -> A X and leave Y unchanged. The old compensation is Y -> Y+D X. Then the exact identity + + [A on X] after [add D X to Y] + = [add (D A^{-1}) X to Y] after [A on X] + +holds on every input, including arbitrary helper dirt. Therefore compensation may be moved to another program cut by computing the inverse-version response D A^{-1}. One must factor the transported map into actual allowed scalar gates and check that every source and target frame can reach the chosen common frame and still reach their next uses. If those finite checks pass, the transformed program has precisely the same full scalar endpoint. It is not enough to compare clean-input columns or to reuse D without the inverse-version factor. + +For a sequence of elementary background gates, D A^{-1} is computed by the opposite column update, in the original prefix order. Thus this theorem supplies a constructive compiler pass with an exact rejection test. The untouched-register case gives a useful safe normal form: each dirty compensation read can be delayed up to the first instruction that touches its helper, while the target remains at frame zero. This special case needs no extra storage and preserves the frame-chain invoice. It is not claimed as an exponent improvement. `transport_compensation.py` implements this normal form on R480: all 480 helper dirt reads move to their last untouched versions, all 720 scalar columns agree exactly, and every deduplicated register frame chain is unchanged. The exact receipt is `transport-bit510/TRANSPORT.json`. This appendix does not claim a new native phase or global-program replay. + +## Bounded screens and scope + +On the original filtered504 source, 100 native nested-elimination trials were preserved; they reached up to 92 pivots and rank188, but became secondary when PR535 moved the frontier. No whole-profile gain is inferred from those counts. + +On the new binding R480 bit source, the exact post-center compensation screen rejected every individual helper under its specified first-B-frame schedule: 448 failed because a transported source frame was already above the target frame, and 23 failed the next-use containment test. The full transported compensator had 1273 incompatible support entries in that schedule. A separate exact screen of 120 additional non-root sum/difference lines, together with all 120 root lines, found no entry response circuit. These are bounded family failures, not a theorem excluding other cuts, joint cancellation, general frames, or other schedules. + +On PR535, all 112 post-center gauges already attain rank one in the intersection of their actual first frames, target first-use caps and donor-kernel caps. The remaining static census examined 27195 first-frame subspaces and found 12 nonzero-nullity line classes and no higher-rank candidate in that restricted interface. A bounded 100-seed presentation search yielded the checked 44-pivot witness above. No optimality claim follows. + +## Structural source references + +Mathlib's matrix transvection file supplies explicit left/right elementary update identities and reverse-inverse product identities. OpenAI's congruence elementary-matrix development supplies `clear_step`: an elementary update clears another entry while preserving an already-cleared prefix. We inspected these actual statements as structural models for the inductive invariant and product order. The new geometric compilation theorem and its changed provider were proved and checked here; they are not asserted to be direct imports or newly Lean-certified theorems. Exact source hashes are in META-SOURCES.json. diff --git a/research/trace-curvature-preload/appendix/static44/README.md b/research/trace-curvature-preload/appendix/static44/README.md new file mode 100644 index 0000000000..6aed83ec92 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/README.md @@ -0,0 +1,7 @@ +# Static44 local construction appendix + +Run `python -B replay.py --out NEW_DIRECTORY` from any working directory. This reconstructs the exact new static response presentation and checks all 728 scalar columns in both orientations, including arbitrary helper dirt, plus44 omitted-correction controls. Python standard library only. The output directory must not exist. + +The local profile changes by -4 rank-one children relative to PR535. The residual inventory becomes56 width-five,156 width-eight,292 width-nine. The global controller, owner charts, phase recipes and outer assembly are NOT replayed here. This appendix does not contribute a claimed final kappa gain. + +The attributed raw and baseline words and old recipe come from PR535 post-center-rank4-global. The gauge/kernel primitives come from PR531's attributed PR484 lineage; their original copyright/assistance notices are preserved. The new selection, replacement proof and constructor are our contribution. No new all-size or analytic interfaces are claimed discharged. diff --git a/research/trace-curvature-preload/appendix/static44/RECIPE.json b/research/trace-curvature-preload/appendix/static44/RECIPE.json new file mode 100644 index 0000000000..68c751bb56 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/RECIPE.json @@ -0,0 +1,168 @@ +{ + "selection": { + "kernel": [ + { + "E": [ + 96 + ], + "donors": [ + 250, + 251, + 256, + 257, + 266, + 267, + 302, + 303 + ], + "pivots": [ + 264, + 265, + 312, + 313, + 314, + 315, + 350, + 351 + ] + }, + { + "E": [ + 102 + ], + "donors": [ + 252, + 253, + 254, + 255, + 278, + 279, + 290, + 291 + ], + "pivots": [ + 276, + 277, + 324, + 325, + 326, + 327, + 338, + 339 + ] + }, + { + "E": [ + 120 + ], + "donors": [ + 238, + 239, + 244, + 245, + 268, + 269, + 292, + 293 + ], + "pivots": [ + 262, + 263, + 322, + 323, + 328, + 329, + 352, + 353 + ] + }, + { + "E": [ + 126 + ], + "donors": [ + 240, + 241, + 242, + 243, + 280, + 281, + 304, + 305 + ], + "pivots": [ + 274, + 275, + 310, + 311, + 316, + 317, + 340, + 341 + ] + }, + { + "E": [ + 480 + ], + "donors": [ + 286, + 287, + 288, + 289, + 298, + 300, + 334, + 335, + 336, + 337, + 346, + 348, + 358, + 360 + ], + "pivots": [ + 299, + 301, + 347, + 349, + 359, + 361, + 370, + 371, + 372, + 373 + ] + }, + { + "E": [ + 486 + ], + "donors": [ + 362, + 363, + 364, + 365, + 374, + 376 + ], + "pivots": [ + 375, + 377 + ] + } + ] + }, + "raw_semantic": "e00e571c80795516eff434392fe48f64ff430a866afd42608808e2f302064275", + "base_semantic": "39a1b5a6b237f52f59ebf55f39b22dc06292bc43403c04aa1f086a0277128b33", + "output_semantic": "f6183f32b354e0feec39170ee29bfad577af23e4697e9f25a0ad9dc2d5c2d9d4", + "profile": { + "1": 2204, + "4": 280, + "8": 8, + "3": 184, + "2": 728, + "6": 56, + "5": 56 + } +} diff --git a/research/trace-curvature-preload/appendix/static44/SOURCE-MANIFEST.json b/research/trace-curvature-preload/appendix/static44/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..468918ea58 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/SOURCE-MANIFEST.json @@ -0,0 +1,16 @@ +{ + "audit_scalar.py": "d22159087c1d0df0edf452aae3a1a7a45bf2cde4ce6e177850e415f9620151e1", + "build.py": "31d68795916985e2abb3207b07c1d3e39ed3560f1b46f18ade0a509278c710dc", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "META-SOURCES.json": "b30c82ad1d707b68e84af85e90b1bab0e41e49ccacda3069b952c790092be920", + "NOTICE-upstream.md": "1547136e6d269fdcef2b68c10a97a786a79a4732a12738363f679bfb282430cd", + "PROOF.md": "d1dafe41a1698d6df575ec86f796bcba08c54fe14b6d69e78f5f6cff8b55de4a", + "README.md": "c4b3ce02012fe97598e76a77877541a8f3387ba4305cee600ee557a48b3493e8", + "RECIPE.json": "973f1975213398f2b711e8ce4eddece181d4cbea83be5b6b650115b9bc43f2eb", + "replay.py": "5b12ea184b3afde41b1028d1926a0d158f2f05585dae6d9024e31424c290bccf", + "gk/gk_common.py": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "gk/gk_word.py": "f027a9273bcf4e0971258c160b7d3b3c196366b32a529cff6e6a0e666b03826b", + "inputs/BASE535.json.gz": "edfffb8e8735e0d1f07c81d818022b705ef0889c2bccc193a2f7a661b9f7d390", + "inputs/OLD-RECIPE.json": "7e5c179246261edd9e1019e81e6e979537f02559da773b993a318f771cb7d763", + "inputs/RAW504.json.gz": "1c6144791dbedf6427e3ee7b4c24fb05b5bf407f6346592f50f8dd8d9638108d" +} diff --git a/research/trace-curvature-preload/appendix/static44/audit_scalar.py b/research/trace-curvature-preload/appendix/static44/audit_scalar.py new file mode 100644 index 0000000000..834e8b5103 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/audit_scalar.py @@ -0,0 +1,55 @@ +"""Independent exact scalar witness for a selected complex kernel word. +Uses immutable correct-word compensation for omission controls; no repaired +compensation is silently supplied to a mutant. No physical-hosting claim. +""" +import sys,json,gzip,hashlib,copy +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +p=Path(__file__).resolve().parent +path=Path(sys.argv[1]);selection=Path(sys.argv[2]);out=Path(sys.argv[3]);w=json.loads(gzip.decompress(path.read_bytes()));sel=json.loads(selection.read_text());v=len(w['ports']);n=2*v+w['report']['R'] +def ident():return[{r:Q(1)}for r in range(n)] +def apply(e,rows): + if e[0]=='scale': + _,t,a,b,*_=e;q=Q(a,b);rows[t]={j:q*x for j,x in rows[t].items()};return + _,t,s,a,b,*_=e;q=Q(a,b) + for j,x in list(rows[s].items()): + z=rows[t].get(j,Q(0))+q*x + if z:rows[t][j]=z + else:rows[t].pop(j,None) +def inv(e,dual=False): + e=copy.deepcopy(e) + if e[0]=='add': + e[3]*=-1 + if dual:e[1],e[2]=e[2],e[1] + else:e[2],e[3]=e[3],e[2] + return e +def replay(es): + rows=ident() + for e in es:apply(e,rows) + return rows +main=w['A']+w['cut']+w['B'];mx=replay(main);dirty=[{}for _ in range(n)] +for r in range(v,2*v):dirty[r]={j:x for j,x in mx[r].items()if j>=2*v} +for e in w['precondition']:apply(e,dirty) +comp=[] +for r in range(v,2*v): + for j,x in sorted(dirty[r].items()): + assert not w.get('start_extra',{}).get(str(j)),('nonzero-frame compensation',j) + comp.append(['add',r,j,-x.numerator,x.denominator,[]]) +cleanup=[inv(e)for e in reversed(w['A']+w['B'])if not v<=e[1]<2*v] +assert[e[:-1]for e in cleanup]==[e[:-1]for e in w['cleanup']] +program=w['precondition']+comp+main+cleanup;expected=ident() +for t in range(v):expected[v+t][t]=Q(1) +assert replay(program)==expected +back=ident() +for t in range(v):back[t][v+t]=Q(-1) +assert replay([inv(e,True)for e in program])==back +controls={} +for cl in sel['kernel']: + for h in cl['pivots']: + aa=[e for e in w['A']if not(e[0]=='add'and e[2]==2*v+h and e[1]>=2*v and e[-1]==cl['E'])] + assert len(aa)> p & 1: x ^= b[p] + if x: + p = x.bit_length() - 1 + for q in b: + if b[q] >> p & 1: b[q] ^= x + b[p] = x + return tuple(b[p] for p in sorted(b, reverse=True)) + + +def widths_of(word): + """residual width of every helper: 9 - dim(entrance frame); 9 when the word has no extension""" + R = word['report']['R'] if 'R' not in word else word['R'] + w = [L] * R + for r, E in word.get('start_extra', {}).items(): + assert 2 * V <= int(r) < 2 * V + R + w[int(r) - 2 * V] = L - len(basis(E)) + return w + + +def split_pad(p): + """a pad of rank p is paid as nested commuting children of rank <= 51 (so that 73^2 > 2*child^2); rank 1 stays 1""" + if p == 0: return [] + n = -(-p // 51); return [p // n + (1 if i < p % n else 0) for i in range(n)] + + +def tile(items): + """Bank tiling of unhosted residuals. items: list of (rep, helper, width); a bank has M = 73 cells. + * width-9 residuals (no wrapper acts on them): first fit in the given order, packed from offset 0, eight per bank, pad rank 1 + (PR #433/#442's tiling and routes [2, slot]); + * ENTERING residuals (width w < 9, paid wrappers, e = 9 - w spectators): banks of their own in which every entering helper is the ONLY + owner of its bank family in its invocation (the one-helper rule of PR #458 extended to banks): bank j holds the j-th entering + helper of each replica, residuals packed from offset 0 in replica order (at most one helper per replica, hence per invocation). + The spectators of an entering helper are the first e cells of the bank beyond every residual cell of the bank (the pad, which no call + uses for a residual, is paid as before: rank 73 - sum of widths; the spectators are borrowed inside it and not deducted). + Returns (assign, banks, pads): assign[(rep, helper)] = (bank, offset, width, pure, spectators) with pure = the bank holds only width-9 + residuals and spectators = () for width 9; pads = Counter of pad ranks (split into children of rank <= 51).""" + assign = {}; pads = Counter(); fill = [] + for z, (rep, h, w) in enumerate(items): # width 9: first fit, as PR #433 (all widths 9 reproduces it exactly) + if w != L: continue + for b, f in enumerate(fill): + if f + w <= M: break + else: + b = len(fill); fill.append(0) + assign[(rep, h)] = (b, fill[b], w, True, ()); fill[b] += w + nwide = len(fill); byrep = {} + for rep, h, w in items: + if w < L: byrep.setdefault(rep, []).append((h, w)) + cells = [0] * max((len(v) for v in byrep.values()), default=0); emax = [0] * len(cells); place = {} + for rep in sorted(byrep): # the j-th entering helper of every replica goes to entering bank j + for j, (h, w) in enumerate(byrep[rep]): + place[(rep, h)] = (nwide + j, cells[j], w); cells[j] += w; emax[j] = max(emax[j], L - w) + for j in range(len(cells)): assert cells[j] + emax[j] <= M, ('entering bank without room for its spectators', j) + for (rep, h), (b, off, w) in place.items(): + assign[(rep, h)] = (b, off, w, False, tuple(range(cells[b - nwide], cells[b - nwide] + L - w))) + fill += cells + for f in fill: + for part in split_pad(M - f): pads[part] += 1 + return assign, len(fill), pads + + +def route(off, w, pure, sp=()): + """owner route of a banked helper residual: PR #433's [2, slot] for width 9 (pure width-9 bank); an entering helper (w < 9) is + [2, offset, width, [spectator cells]] with e = 9 - w spectators""" + if w == L: assert pure and not sp; return [2, off // L] + assert not pure and len(sp) == L - w; return [2, off, w, list(sp)] + + +def unhosted_stock(widths): + """live stock and padding histogram of the unhosted (parent) template, per stage x nine""" + R = len(widths) + _, nb, pads = tile([(rep, h, widths[h]) for rep in range(T) for h in range(R)]) + return DATA + L * nb, Counter({r: z * L for r, z in pads.items()}) diff --git a/research/trace-curvature-preload/appendix/static44/gk/gk_word.py b/research/trace-curvature-preload/appendix/static44/gk/gk_word.py new file mode 100644 index 0000000000..15782ba625 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/gk/gk_word.py @@ -0,0 +1,194 @@ +"""Apply a frozen selection (shared-donor kernel + entrance gauges) to PR #433's complex word. Apache-2.0. +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +usage: gk_word.py BASE_FULL-WORD.json.gz SELECTION.json OUT_FULL-WORD.json.gz +An empty selection ({}) copies the input byte for byte (regression anchor). + +selection = {"kernel": [{"E": [x], "donors": [h..], "pivots": [h..]}..], "gauge": {"h": [x..]}} (h = helper index 0..R-1) +Kernel (PR #417/#435/#434/#440): a pivot starts at E; every donor receives donor += -q * pivot at frame E before the main +word, where col(pivot) = sum q_d col(d) are the exact dirty-response columns; the pivot's frame-zero compensation vanishes. +Gauge (#401/#408-#416): the compensation target += -C[t,h] * helper of helper h is executed at frame E_h as the first gates +of the main word; h starts at E_h and its targets climb to the level L_t = largest E over their entering helpers. +The exact verification is the arbitrary-dirt replay of audit_gk.py; this module also checks the structural conditions.""" +import copy, gzip, hashlib, json, sys +from collections import Counter, defaultdict +from fractions import Fraction as Q +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from gk_common import * + + +def apply_op(e, rows): + if e[0] == 'scale': + _, t, a, b, *_ = e; q = Q(a, b); rows[t] = {j: q * x for j, x in rows[t].items()} + else: + _, t, s, a, b, *_ = e; q = Q(a, b) + for j, x in list(rows[s].items()): + z = rows[t].get(j, Q(0)) + q * x + if z: rows[t][j] = z + else: rows[t].pop(j, None) + + +def inverse(e, F): + e = copy.deepcopy(e) + if e[0] == 'add': e[3] *= -1 + else: e[2], e[3] = e[3], e[2] + e[-1] = list(F); return e + + +def responses(word): + """dirty-response columns col[h] = {target: coefficient} of the unmodified word (after the frame-zero preconditioner)""" + R = word['report']['R']; n = 2 * V + R + rows = [{r: Q(1)} for r in range(n)] + for e in word['A'] + word['cut'] + word['B']: apply_op(e, rows) + dirty = [{} for _ in range(n)] + for r in range(V, 2 * V): dirty[r] = {j: x for j, x in rows[r].items() if j >= 2 * V} + for e in word['precondition']: apply_op(e, dirty) + col = [{} for _ in range(R)] + for r in range(V, 2 * V): + for j, x in dirty[r].items(): col[j - 2 * V][r - V] = x + return col + + +def first_frames(word): + first = {} + for seq in (word['A'], word['B']): + for e in seq: + F = basis(e[-1]) + for r in [e[1]] + ([e[2]] if e[0] == 'add' else []): + if r >= 2 * V: first.setdefault(r - 2 * V, F) + return first + + +def solve_relation(col, donors, p): + """exact rational c with col[p] = sum_d c_d col[d]; None if p is not in the span""" + ts = sorted({t for d in donors for t in col[d]} | set(col[p])) + idx = {t: i for i, t in enumerate(ts)} + Mx = [[Q(0)] * (len(donors) + 1) for _ in ts] + for ci, d in enumerate(donors): + for t, x in col[d].items(): Mx[idx[t]][ci] = x + for t, x in col[p].items(): Mx[idx[t]][-1] = x + piv = []; r = 0 + for c in range(len(donors)): + pr = next((i for i in range(r, len(Mx)) if Mx[i][c]), None) + if pr is None: continue + Mx[r], Mx[pr] = Mx[pr], Mx[r]; q = Mx[r][c]; Mx[r] = [x / q for x in Mx[r]] + for i in range(len(Mx)): + if i != r and Mx[i][c]: + f = Mx[i][c]; Mx[i] = [a - f * b for a, b in zip(Mx[i], Mx[r])] + piv.append(c); r += 1 + if any(Mx[i][-1] for i in range(r, len(Mx))): return None + assert r == len(donors), 'donors must have independent response columns' + return {donors[c]: Mx[i][-1] for i, c in enumerate(piv) if Mx[i][-1]} + + +def span(U): + s = {0} + for b in U: s |= {x ^ b for x in s} + return s + + +def perp(x): return basis([z for z in range(1, 512) if not (x & z).bit_count() % 2]) + + +def profile(word): + """local paid profile of a gk word by direct simulation of the frame chains (second implementation: audit_gk.py)""" + R = word['report']['R']; n = 2 * V + R; P = word['ports'] + cur = {} + for r in range(n): + cur[r] = (P[r],) if r < V else ((basis(word['start_extra'][str(r)]) if str(r) in word.get('start_extra', {}) else ()) if r >= 2 * V else ()) + paid = Counter() + def climb(r, F): + F = basis(F); o = cur[r] + assert basis(list(o) + list(F)) == F, ('frame violation', r, o, F) + if o != F: paid[len(F) - len(o)] += 1; cur[r] = F + lev = {int(t): basis(E) for t, E in word.get('target_levels', {}).items()} + for seq, part in ((word['A'], 'A'), (word['B'], 'B')): + if part == 'B': + for r, f in zip(word['centers'], word['center_frames']): + assert cur[r] == basis(f), 'centre frame' + served = sorted({lev.get(e[1] - V, ()) for e in word['cut'] if e[2] == r}, key=lambda E: -len(E)) + o = basis(f) + for Lv in served: + assert span(Lv) <= span(o), 'served levels must descend inside the centre frame' + if Lv != o: paid[len(o) - len(Lv)] += 1; o = Lv + for t in range(V): assert cur[V + t] == lev.get(t, ()), 'target level at the centre scatter' + for e in seq: + for r in [e[1]] + ([e[2]] if e[0] == 'add' else []): climb(r, e[-1]) + for r in range(n): climb(r, FULL if (r < V or r >= 2 * V) else perp(P[r - V])) + return paid + + +def global_profile(local, widths): + """unhosted nine-stage profile: local x (stages*replicas) + the 240*8 idle children per rank + bank pads""" + live, pads = unhosted_stock(widths) + g = Counter({r: z * L * T for r, z in local.items()}) + for r in (16, 8, 32, 8, 48, 8, 48, 32, 16): g[r] += 240 * T + g.update(pads) + return live, g + + +def build(word, sel, check=True): # check=False only for the mutation controls that must be caught by the certifying scripts + if not sel: return word + w = copy.deepcopy(word); R = w['report']['R'] + col = responses(word); first = first_frames(word) + gauge = {int(h): basis(E) for h, E in sel.get('gauge', {}).items()} + classes = sel.get('kernel', []) + pivots = {p for c in classes for p in c['pivots']}; donors = {d for c in classes for d in c['donors']} + assert not (pivots & donors) and not (pivots | donors) & set(gauge) and len(pivots) == sum(len(c['pivots']) for c in classes) + # --- structural conditions ------------------------------------------------------------------------------------- + for h, E in gauge.items(): + assert not check or span(E) <= span(first[h]), ('gauge entrance outside the first frame', h) + levels = defaultdict(list) + for h, E in gauge.items(): + for t in col[h]: levels[t].append(E) + for t, Es in levels.items(): # pairwise nested comps per target + for a in Es: + for b in Es: assert not check or span(a) <= span(b) or span(b) <= span(a), ('non-nested gauges at target', t) + lev = {t: max(Es, key=len) for t, Es in levels.items()} + for k, r in enumerate(w['centers']): # chain per centre, inside the centre frame + served = {lev.get(e[1] - V, ()) for e in w['cut'] if e[2] == r} + for a in served: + for b in served: assert not check or span(a) <= span(b) or span(b) <= span(a), ('centre chain', k) + top = max(served, key=len) + assert not check or span(top) <= span(basis(w['center_frames'][k])), ('level outside centre frame', k) + # --- gates ---------------------------------------------------------------------------------------------------------- + gates = [] + for h, E in sorted(gauge.items(), key=lambda kv: (len(kv[1]), kv[0])): + for t, x in sorted(col[h].items()): + c = -x; gates.append(['add', V + t, 2 * V + h, c.numerator, c.denominator, list(E)]) + pre = [] + start = {2 * V + h: list(E) for h, E in gauge.items()} + for cl in sorted(classes, key=lambda c: (len(c['E']), c['E'])): + E = basis(cl['E']) + for x in [*cl['donors'], *cl['pivots']]: assert span(E) <= span(first[x]), ('kernel entrance outside the first frame', x) + for p in cl['pivots']: + rel = solve_relation(col, cl['donors'], p) + assert rel is not None, ('pivot response not in the donor span', p) + start[2 * V + p] = list(E) + for d, c in rel.items(): + q = -c; pre.append(['add', 2 * V + d, 2 * V + p, q.numerator, q.denominator, list(E)]) + w['A'] = gates + pre + w['A'] + w['cleanup'] = [inverse(e, FULL) for e in reversed(w['A'] + w['B']) if not V <= e[1] < 2 * V] + w['start_extra'] = {str(r): list(E) for r, E in sorted(start.items())} + w['target_levels'] = {str(t): list(E) for t, E in sorted(lev.items()) if E} + if not check: return w + prof = profile(w); widths = widths_of(w) + live, g = global_profile(prof, widths) + w['report']['local_profile'] = {str(k): z for k, z in sorted(prof.items())} + w['report']['global_profile'] = {str(k): z for k, z in sorted(g.items())} + w['report']['live'] = live + w['report']['entrance_rank'] = sum(L - x for x in widths); w['report']['entering_helpers'] = sum(1 for x in widths if x < L) + w['report']['selection_sha256'] = hashlib.sha256(json.dumps(sel, sort_keys=True).encode()).hexdigest() + return w + + +def dump(w): return gzip.compress(json.dumps(w, sort_keys=True, separators=(',', ':')).encode(), mtime=0) + + +if __name__ == '__main__': + src, selp, out = map(Path, sys.argv[1:4]) + sel = json.loads(selp.read_text()) + if not sel: out.write_bytes(src.read_bytes()); print('empty selection: copied byte for byte'); sys.exit(0) + word = json.load(gzip.open(src)); w = build(word, sel); out.write_bytes(dump(w)) + print('gk word: entering helpers', w['report']['entering_helpers'], 'entrance rank', w['report']['entrance_rank'], + 'local profile', w['report']['local_profile'], 'unhosted live', w['report']['live']) diff --git a/research/trace-curvature-preload/appendix/static44/inputs/BASE535.json.gz b/research/trace-curvature-preload/appendix/static44/inputs/BASE535.json.gz new file mode 100644 index 0000000000..bcc1647b7d Binary files /dev/null and b/research/trace-curvature-preload/appendix/static44/inputs/BASE535.json.gz differ diff --git a/research/trace-curvature-preload/appendix/static44/inputs/OLD-RECIPE.json b/research/trace-curvature-preload/appendix/static44/inputs/OLD-RECIPE.json new file mode 100644 index 0000000000..52d4b5f382 --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/inputs/OLD-RECIPE.json @@ -0,0 +1,1163 @@ +{ + "source_sha256": "1c6144791dbedf6427e3ee7b4c24fb05b5bf407f6346592f50f8dd8d9638108d", + "selection": { + "kernel": [ + { + "E": [ + 510 + ], + "donors": [ + 242, + 243, + 244, + 245, + 254, + 256, + 266, + 267, + 268, + 269, + 270, + 271, + 278, + 280, + 282, + 283, + 290, + 292, + 294, + 295, + 306, + 307 + ], + "pivots": [ + 255, + 257, + 279, + 281, + 291, + 293, + 302, + 303, + 304, + 305 + ] + }, + { + "E": [ + 504 + ], + "donors": [ + 238, + 239, + 240, + 241, + 250, + 252, + 314, + 315, + 316, + 317, + 318, + 319, + 326, + 328, + 330, + 331, + 338, + 340, + 342, + 343, + 354, + 355 + ], + "pivots": [ + 251, + 253, + 327, + 329, + 339, + 341, + 350, + 351, + 352, + 353 + ] + }, + { + "E": [ + 486 + ], + "donors": [ + 262, + 263, + 264, + 265, + 274, + 276, + 310, + 311, + 312, + 313, + 322, + 324, + 362, + 364 + ], + "pivots": [ + 275, + 277, + 323, + 325, + 363, + 365, + 374, + 375, + 376, + 377 + ] + }, + { + "E": [ + 480 + ], + "donors": [ + 286, + 287, + 288, + 289, + 298, + 300, + 334, + 335, + 336, + 337, + 346, + 348, + 358, + 360 + ], + "pivots": [ + 299, + 301, + 347, + 349, + 359, + 361, + 370, + 371, + 372, + 373 + ] + } + ], + "gauge": { + "224": [ + 6 + ], + "225": [ + 6 + ], + "226": [ + 24 + ], + "227": [ + 24 + ], + "228": [ + 30 + ], + "229": [ + 30 + ], + "230": [ + 30 + ], + "231": [ + 30 + ], + "232": [ + 24 + ], + "233": [ + 24 + ], + "234": [ + 6 + ], + "235": [ + 6 + ], + "236": [ + 6 + ], + "237": [ + 6 + ], + "246": [ + 6 + ], + "247": [ + 6 + ], + "248": [ + 6 + ], + "249": [ + 6 + ], + "258": [ + 6 + ], + "259": [ + 6 + ], + "260": [ + 24 + ], + "261": [ + 24 + ], + "272": [ + 24 + ], + "273": [ + 24 + ], + "284": [ + 30 + ], + "285": [ + 30 + ], + "296": [ + 30 + ], + "297": [ + 30 + ], + "308": [ + 30 + ], + "309": [ + 30 + ], + "320": [ + 30 + ], + "321": [ + 30 + ], + "332": [ + 24 + ], + "333": [ + 24 + ], + "344": [ + 24 + ], + "345": [ + 24 + ], + "356": [ + 6 + ], + "357": [ + 6 + ], + "366": [ + 6 + ], + "367": [ + 6 + ], + "368": [ + 6 + ], + "369": [ + 6 + ], + "378": [ + 6 + ], + "379": [ + 6 + ], + "380": [ + 6 + ], + "381": [ + 6 + ], + "382": [ + 24 + ], + "383": [ + 24 + ], + "384": [ + 30 + ], + "385": [ + 30 + ], + "386": [ + 30 + ], + "387": [ + 30 + ], + "388": [ + 24 + ], + "389": [ + 24 + ], + "390": [ + 6 + ], + "391": [ + 6 + ], + "392": [ + 6 + ], + "393": [ + 6 + ], + "394": [ + 6 + ], + "396": [ + 6 + ], + "400": [ + 6 + ], + "401": [ + 6 + ], + "402": [ + 6 + ], + "404": [ + 6 + ], + "408": [ + 6 + ], + "409": [ + 6 + ], + "410": [ + 6 + ], + "412": [ + 6 + ], + "416": [ + 24 + ], + "417": [ + 24 + ], + "418": [ + 24 + ], + "420": [ + 24 + ], + "424": [ + 24 + ], + "425": [ + 24 + ], + "426": [ + 24 + ], + "428": [ + 24 + ], + "432": [ + 30 + ], + "433": [ + 30 + ], + "434": [ + 30 + ], + "436": [ + 30 + ], + "440": [ + 30 + ], + "441": [ + 30 + ], + "442": [ + 30 + ], + "444": [ + 30 + ], + "448": [ + 30 + ], + "449": [ + 30 + ], + "450": [ + 30 + ], + "452": [ + 30 + ], + "456": [ + 30 + ], + "457": [ + 30 + ], + "458": [ + 30 + ], + "460": [ + 30 + ], + "464": [ + 24 + ], + "465": [ + 24 + ], + "466": [ + 24 + ], + "468": [ + 24 + ], + "472": [ + 24 + ], + "473": [ + 24 + ], + "474": [ + 24 + ], + "476": [ + 24 + ], + "480": [ + 6 + ], + "481": [ + 6 + ], + "482": [ + 6 + ], + "484": [ + 6 + ], + "488": [ + 6 + ], + "489": [ + 6 + ], + "490": [ + 6 + ], + "492": [ + 6 + ], + "496": [ + 6 + ], + "497": [ + 6 + ], + "498": [ + 6 + ], + "500": [ + 6 + ] + } + }, + "rank4_groups": [ + { + "E": [ + 389, + 96, + 24, + 3 + ], + "donors": [ + 472, + 473, + 474, + 476 + ], + "pivots": [ + 475, + 477, + 478, + 479 + ], + "relations": { + "475": { + "472": "1", + "473": "1", + "474": "-1" + }, + "477": { + "472": "-1", + "473": "1", + "476": "1" + }, + "478": { + "472": "-1", + "474": "1", + "476": "1" + }, + "479": { + "473": "1", + "474": "-1", + "476": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 401, + 96, + 9, + 6 + ], + "donors": [ + 480, + 481, + 482, + 484 + ], + "pivots": [ + 483, + 485, + 486, + 487 + ], + "relations": { + "483": { + "480": "1", + "481": "1", + "482": "-1" + }, + "485": { + "480": "-1", + "481": "1", + "484": "1" + }, + "486": { + "480": "-1", + "482": "1", + "484": "1" + }, + "487": { + "481": "1", + "482": "-1", + "484": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 449, + 33, + 24, + 6 + ], + "donors": [ + 496, + 497, + 498, + 500 + ], + "pivots": [ + 499, + 501, + 502, + 503 + ], + "relations": { + "499": { + "496": "1", + "497": "1", + "498": "-1" + }, + "501": { + "496": "-1", + "497": "1", + "500": "1" + }, + "502": { + "496": "-1", + "498": "1", + "500": "1" + }, + "503": { + "497": "1", + "498": "-1", + "500": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 297, + 169, + 120, + 6 + ], + "donors": [ + 488, + 489, + 490, + 492 + ], + "pivots": [ + 491, + 493, + 494, + 495 + ], + "relations": { + "491": { + "488": "1", + "489": "1", + "490": "-1" + }, + "493": { + "488": "-1", + "489": "1", + "492": "1" + }, + "494": { + "488": "-1", + "490": "1", + "492": "1" + }, + "495": { + "489": "1", + "490": "-1", + "492": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 291, + 163, + 102, + 24 + ], + "donors": [ + 464, + 465, + 466, + 468 + ], + "pivots": [ + 467, + 469, + 470, + 471 + ], + "relations": { + "467": { + "464": "1", + "465": "1", + "466": "-1" + }, + "469": { + "464": "-1", + "465": "1", + "468": "1" + }, + "470": { + "464": "-1", + "466": "1", + "468": "1" + }, + "471": { + "465": "1", + "466": "-1", + "468": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 390, + 75, + 45, + 30 + ], + "donors": [ + 456, + 457, + 458, + 460 + ], + "pivots": [ + 459, + 461, + 462, + 463 + ], + "relations": { + "459": { + "456": "1", + "457": "1", + "458": "-1" + }, + "461": { + "456": "-1", + "457": "1", + "460": "1" + }, + "462": { + "456": "-1", + "458": "1", + "460": "1" + }, + "463": { + "457": "1", + "458": "-1", + "460": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 267, + 139, + 96, + 30 + ], + "donors": [ + 448, + 449, + 450, + 452 + ], + "pivots": [ + 451, + 453, + 454, + 455 + ], + "relations": { + "451": { + "448": "1", + "449": "1", + "450": "-1" + }, + "453": { + "448": "-1", + "449": "1", + "452": "1" + }, + "454": { + "448": "-1", + "450": "1", + "452": "1" + }, + "455": { + "449": "1", + "450": "-1", + "452": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 390, + 96, + 20, + 10 + ], + "donors": [ + 440, + 441, + 442, + 444 + ], + "pivots": [ + 443, + 445, + 446, + 447 + ], + "relations": { + "443": { + "440": "1", + "441": "1", + "442": "-1" + }, + "445": { + "440": "2", + "441": "-2", + "444": "1" + }, + "446": { + "440": "2", + "442": "-2", + "444": "1" + }, + "447": { + "441": "-2", + "442": "2", + "444": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 298, + 170, + 102, + 30 + ], + "donors": [ + 432, + 433, + 434, + 436 + ], + "pivots": [ + 435, + 437, + 438, + 439 + ], + "relations": { + "435": { + "432": "1", + "433": "1", + "434": "-1" + }, + "437": { + "432": "2", + "433": "-2", + "436": "1" + }, + "438": { + "432": "2", + "434": "-2", + "436": "1" + }, + "439": { + "433": "-2", + "434": "2", + "436": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 390, + 68, + 34, + 24 + ], + "donors": [ + 424, + 425, + 426, + 428 + ], + "pivots": [ + 427, + 429, + 430, + 431 + ], + "relations": { + "427": { + "424": "1", + "425": "1", + "426": "-1" + }, + "429": { + "424": "2", + "425": "-2", + "428": "1" + }, + "430": { + "424": "2", + "426": "-2", + "428": "1" + }, + "431": { + "425": "-2", + "426": "2", + "428": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 260, + 132, + 96, + 24 + ], + "donors": [ + 416, + 417, + 418, + 420 + ], + "pivots": [ + 419, + 421, + 422, + 423 + ], + "relations": { + "419": { + "416": "1", + "417": "1", + "418": "-1" + }, + "421": { + "416": "2", + "417": "-2", + "420": "1" + }, + "422": { + "416": "2", + "418": "-2", + "420": "1" + }, + "423": { + "417": "-2", + "418": "2", + "420": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 408, + 80, + 40, + 6 + ], + "donors": [ + 400, + 401, + 402, + 404 + ], + "pivots": [ + 403, + 405, + 406, + 407 + ], + "relations": { + "403": { + "400": "1", + "401": "1", + "402": "-1" + }, + "405": { + "400": "-1", + "401": "1", + "404": "1" + }, + "406": { + "400": "-1", + "402": "1", + "404": "1" + }, + "407": { + "401": "1", + "402": "-1", + "404": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 272, + 144, + 96, + 6 + ], + "donors": [ + 408, + 409, + 410, + 412 + ], + "pivots": [ + 411, + 413, + 414, + 415 + ], + "relations": { + "411": { + "408": "1", + "409": "1", + "410": "-1" + }, + "413": { + "408": "-1", + "409": "1", + "412": "1" + }, + "414": { + "408": "-1", + "410": "1", + "412": "1" + }, + "415": { + "409": "1", + "410": "-1", + "412": "1" + } + }, + "donor_gauge_lines_fit": true + }, + { + "E": [ + 320, + 192, + 24, + 6 + ], + "donors": [ + 392, + 393, + 394, + 396 + ], + "pivots": [ + 395, + 397, + 398, + 399 + ], + "relations": { + "395": { + "392": "1", + "393": "1", + "394": "-1" + }, + "397": { + "392": "-1", + "393": "1", + "396": "1" + }, + "398": { + "392": "-1", + "394": "1", + "396": "1" + }, + "399": { + "393": "1", + "394": "-1", + "396": "1" + } + }, + "donor_gauge_lines_fit": true + } + ], + "rank4_anchor_after_post_gauge_additions": 320, + "operation_order": [ + "A with original static40 kernels", + "center cut", + "112 post-center gauge compensations", + "56 rank-four pivot injections", + "native B", + "inverse source/helper cleanup" + ], + "report": { + "R": 504, + "borrowed_output_pairs": 56, + "centre_ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "cst": 64, + "first_load_join_counts": { + "4": 112 + }, + "h": 9, + "local_profile": { + "1": 2240, + "2": 888, + "3": 216, + "4": 168, + "5": 56, + "6": 56, + "8": 8 + }, + "local_rank_mass": 6016, + "m": 73, + "scope": "Clean scalar identity and all literal monotone local frames only; arbitrary-dirt compensation, entrance kernels, exact phase recipes, and global hosting/pricing are not yet certified.", + "selected_load_join_counts": { + "6": 112 + }, + "selected_partitions": [ + 0, + 0 + ], + "source_and_helper_cleanup_exact_on_clean_columns": true, + "source_columns_exact": 112, + "status": "EXACT_RELATIONS_AND_FRAMES_PENDING_INDEPENDENT_REPLAY", + "v": 112, + "width_inventory": { + "5": 56, + "8": 152, + "9": 296 + }, + "post_center_gauges": 112, + "post_center_compensation_additions": 320, + "entrance_rank": 376, + "entering_helpers": 208, + "rank4_kernel_groups": 14, + "rank4_kernel_pivots": 56, + "rank4_kernel_additions": 168, + "post_gauge_kernel_anchor": 320 + }, + "output_sha256": "5d510cf5588450b520cd6481d328b3849a31d56dfb250b7c542a5edf9f06052f", + "output_uncompressed_sha256": "66ce5aab59b0469229ab4cf1d7e01a92b06170472618ff6256c9f1f15a367f68" +} diff --git a/research/trace-curvature-preload/appendix/static44/inputs/RAW504.json.gz b/research/trace-curvature-preload/appendix/static44/inputs/RAW504.json.gz new file mode 100644 index 0000000000..903eeb2161 Binary files /dev/null and b/research/trace-curvature-preload/appendix/static44/inputs/RAW504.json.gz differ diff --git a/research/trace-curvature-preload/appendix/static44/replay.py b/research/trace-curvature-preload/appendix/static44/replay.py new file mode 100644 index 0000000000..ef5642ccfd --- /dev/null +++ b/research/trace-curvature-preload/appendix/static44/replay.py @@ -0,0 +1,9 @@ +"""Standalone exact local-only static44 reconstruction and scalar audit.""" +from pathlib import Path +import argparse,subprocess,sys +if not __debug__:raise SystemExit('Assertions must remain enabled.') +p=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);a=ap.parse_args();assert not a.out.exists() +subprocess.run([sys.executable,'-B',str(p/'build.py'),'--raw',str(p/'inputs/RAW504.json.gz'),'--base',str(p/'inputs/BASE535.json.gz'),'--old-recipe',str(p/'inputs/OLD-RECIPE.json'),'--recipe',str(p/'RECIPE.json'),'--gk-dir',str(p/'gk'),'--out',str(a.out)],check=True) +subprocess.run([sys.executable,'-B',str(p/'audit_scalar.py'),str(a.out/'FULL-WORD.json.gz'),str(a.out/'SELECTION.json'),str(a.out/'SCALAR-AUDIT.json')],check=True) +print('PASS standalone local-only appendix') diff --git a/research/trace-curvature-preload/code/assemble_meta.py b/research/trace-curvature-preload/code/assemble_meta.py new file mode 100644 index 0000000000..cf01fe20f2 --- /dev/null +++ b/research/trace-curvature-preload/code/assemble_meta.py @@ -0,0 +1,177 @@ +"""Compose fresh preload60 bit with the pinned, unchanged PR535 complex supplier. + +Prepared for icekylinx with GPT-6 Astra assistance, Apache-2.0. +Adapted from the attributed PR531 assembly. Both rational moment engines and +the 47-constraint outer engine remain pinned inherited implementations. +The complex operator is a cited conditional dependency; the changed bit operator is freshly reconstructed. +Adaptation: fresh bit invoice and source hashes replace the cited bit receipt. +Usage: assemble_meta.py PACKAGE BIT_RESULT OUTDIR +""" +import hashlib +import importlib.util +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +if not __debug__: + raise SystemExit('Run with assertions enabled.') +assert __debug__, 'Run with assertions enabled.' +ROOT, B, O = map(Path, sys.argv[1:4]); O.mkdir(parents=True, exist_ok=True) +BIT_COMMIT = '64edee18af02aab0c1696b677a0287dd0146381b' +BIT_EXPECTED_SHA256 = '19b861f69f7602e47b390d472b487d044bff4230b250520807537c213ad0249f' + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def load(name): + path = ROOT / 'vendor/e8-bit-carrier-skeleton/code/hub/e8-r740-replica32/code/engines' / (name + '.py') + spec = importlib.util.spec_from_file_location('combined_' + name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def decimal(value, places): + scaled = value * 10 ** places + assert scaled.denominator == 1 + digits = str(scaled.numerator).zfill(places + 1) + return digits[:-places] + '.' + digits[-places:] + + +M, Other, Outer = [load(name) for name in ['moment', 'base_two_moment', 'outer']] +owner = json.loads((ROOT / 'inputs/PR535-OWNERS-AND-PROFILE.json').read_text()) +inv = json.loads((ROOT / 'inputs/PR535-PREFIX-AND-INVOICE.json').read_text()) +host = json.loads((ROOT / 'inputs/PR535-HOSTED.json').read_text()) +assert owner['template_sha256'] == inv['template_sha256'] == host['template_sha256'] +assert inv['owner_audit_sha256'] == sha(ROOT / 'inputs/PR535-OWNERS-AND-PROFILE.json') +assert all(inv['strict_checks'].values()) +P = {int(rank): count for rank, count in owner['paid_profile'].items()} +m, W = 73, owner['live'] +assert m * W - sum(rank * count for rank, count in P.items()) == 2560 + + +def two_moments(profile, dimension, live, lower): + """Keep the full rational sign intervals for both independent engines.""" + fallback = 32 * dimension * dimension * sum(profile.values()) + receipts = [] + for endpoint, accept in [(lower, True), (lower + Q(1, 10**24), False)]: + lo, hi = M.moment(profile, dimension, live, endpoint, True) + a, b = Other.moment(dimension, live, list(profile.items()), endpoint) + f, g = Other.moment(dimension, live, [(1, fallback)], endpoint) + a += f / 10**16 + b += g / 10**16 + assert (hi < 1 and b < 1) if accept else (lo > 1 and a > 1) + receipts.append(dict(endpoint=str(endpoint), accept=accept, + mercator=[str(lo - 1), str(hi - 1)], + base_two=[str(a - 1), str(b - 1)])) + return receipts + + +cert = M.certify(P, m, W, True) +b, bp = Q(cert['lower']), Q(cert['upper']) +assert bp - b == Q(1, 10**24) +complex_receipts = two_moments(P, m, W, b) + +# These checks bind and reprice the freshly reconstructed bit invoice. +# Native local and global physical admission are separately source-bound. +bit = json.loads(B.read_text()) +assert bit['status'] == 'PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY' +bitP = {int(rank): count for rank, count in bit['bit_profile'].items()} +bit_inv = bit['bit'] +bm, bW = 64, bit_inv['live'] +assert (bm, bW, bit['stages'], bit['replicas']) == (64, 30720, 9, 32) +assert sum(rank * count for rank, count in bitP.items()) == bit_inv['rank_mass'] +assert bm * bW - bit_inv['rank_mass'] == 9984 +assert max(bitP) == bit_inv['maxchild'] == 8 +assert bm * bm > 2 * 64 * max(bitP) +assert bit_inv['physical'] == bW + 9 == 30729 +assert bit_inv['hosted_residuals'] == 480 * 9 * 32 +assert bit_inv['bank_assignments'] == 0 +assert bit_inv['prefix_bits'] < 256 +assert bit_inv['prefix_bits'] < bit_inv['charged_prefix_bits'] == 256 +assert bit_inv['two_level_coefficient_bits'] < bit_inv['charged_two_level_coefficient_bits'] == 512 +assert bit_inv['row_coefficient'] < 20161 +c = Q(bit['bit_lower']) +assert c == Q(bit['bit_lower_decimal']) +bit_receipts = two_moments(bitP, bm, bW, c) + +eta = beta = grid = Q(1, 10**18) +s = min(c, (1 - beta) * b) - Q(1, 10**24) +assert 0 < s < c and s < (1 - beta) * b +coeff = bit_inv['charged_two_level_coefficient_bits'] +row = max(20161, bit_inv['row_coefficient'], inv['finite']['physical_row_coefficient']) +chain, cuts = [Q(384599, 10**10)], [] + + +def ceil(value): + return -(-value.numerator // value.denominator) + + +for _ in range(6): + old = chain[-1] + a = (1 - s) * s + s * old + gap = min(s - a, 1 - a - s, 1 - a - s * (1 - old), 1 - s) + assert old < a < s < 1 - a and gap > 0 + cut = max(ceil(36 / gap**2), ceil(2 * (4 + coeff) / gap)) + assert cut * gap**2 >= 36 and cut * gap >= 2 * (4 + coeff) + cuts.append(dict(gap=str(gap), cutoff_log2=str(cut))) + chain.append(a) +q = chain[-1] * (1 - 2 * eta) +margin = (1 - eta) * q / (1 + q) +ticks = margin / grid +kap = grid * ((ticks.numerator - 1) // ticks.denominator) +bridge = {'semantic': {'C0': {'base': 2, 'exponent': 210000}, 'strict_literal_gap': 1}, + 'rows': {'degree_gap': Q(10**6) - Q(51 * row, 25)}} +assembly = Outer.assembly(chain[-1], b, bridge, kap, eta=eta, beta=beta) +assert len(assembly['strict_constraints']) == 47 +assert all(value > 0 for value in assembly['strict_constraints'].values()) +controls = [] +for name, k, e, be in [('next_grid', kap + grid, eta, beta), + ('zero_eta', kap, Q(0), beta), + ('zero_beta', kap, eta, Q(0)), + ('unit_beta', kap, eta, Q(1))]: + try: + Outer.assembly(chain[-1], b, bridge, k, eta=e, beta=be) + except AssertionError: + controls.append(name) + else: + raise AssertionError(name) + +baselines = {'PR535': Q('0.001584931111785787'), 'prior_tn22': Q('0.001538356846647141'), + 'PR531': Q('0.001517760977820331'), + 'rejected_POST208_checkpoint': Q('0.001543640781718742'), + 'PR533': Q('0.001524207950793244')} +res = dict( + status='PASS_FRESH_PRELOAD60_BIT_AND_PINNED_PR535_COMPLEX', + complex_lower=str(b), complex_decimal=decimal(b, 24), + next_b_rejected=str(bp), exact_moment_receipts=complex_receipts, + bit_lower=str(c), bit_decimal=decimal(c, 24), + bit_exact_moment_receipts=bit_receipts, + bit_result_sha256=sha(B), + complex_dependency={'pull_request':535,'commit':'0d343e2f813f962405481f83d8935299812a7a1c','path':'research/post-center-rank4-global'}, + bit_dependency={'pull_request':510,'commit':BIT_COMMIT,'changed_word':'preload60','fresh_bit_receipt_sha256':sha(B)}, + bit_prefix_bits=bit_inv['charged_prefix_bits'], + bit_charged_two_level_coefficient_bits=coeff, + external_row_allowance=row, + kappa=str(kap), kappa_decimal=decimal(kap, 18), + binding_component='bit' if c < (1 - beta) * b else 'complex', + improvements={name: {'baseline': str(value), + 'relative_gain': str(kap / value - 1), + 'percent_display': f'{float(100 * (kap / value - 1)):.8f}'} + for name, value in baselines.items()}, + strict_outer_constraints={k: str(v) for k, v in assembly['strict_constraints'].items()}, + outer_controls=controls, bootstrap=cuts, + complex_template_sha256=host['template_sha256'], + owner_audit_sha256=sha(ROOT / 'inputs/PR535-OWNERS-AND-PROFILE.json'), + invoice_sha256=sha(ROOT / 'inputs/PR535-PREFIX-AND-INVOICE.json'), + bit_scope='The changed bit word is freshly reconstructed, replayed and admitted by the native local and hosted-global checkers. The unchanged complex supplier is the pinned PR535 cited dependency.', + scope='Conditional finite witness under the retained all-size compiler, ' + 'common-label/mutable-basis, whole-call hosting, restored-work, ' + 'precision/tape and analytic-transfer contracts. Fresh changed-bit admission ' + 'and finite invoice are separately hash-bound; the unchanged complex supplier is cited, not reconstructed. No unconditional theorem is claimed.') +(O / 'EXACT-ASSEMBLY.json').write_text(json.dumps(res, indent=2) + '\n') +print(res['status'], 'b', res['complex_decimal'], 'kappa', res['kappa_decimal']) +print(json.dumps(res['improvements'], sort_keys=True)) diff --git a/research/trace-curvature-preload/code/audit_curvature.py b/research/trace-curvature-preload/code/audit_curvature.py new file mode 100644 index 0000000000..64090bd040 --- /dev/null +++ b/research/trace-curvature-preload/code/audit_curvature.py @@ -0,0 +1,35 @@ +"""Exact finite curvature-cone certificate; independent of moment engines.""" +import json,sys +from pathlib import Path + +def certificate(old,new): + old={int(r):n for r,n in old.items()};new={int(r):n for r,n in new.items()} + assert all(isinstance(n,int) and n>=0 for n in list(old.values())+list(new.values())) + assert all(r>=1 for r in [*old,*new]) + R=max([1,*old,*new]);d={r:new.get(r,0)-old.get(r,0) for r in range(1,R+1)} + assert sum(d.values())==sum(r*n for r,n in d.items())==0 + C={j:sum((j-r)*d[r]for r in range(1,j))for j in range(1,R+1)} + assert C[1]==C[R]==0 and all(x>=0 for x in C.values()) + assert all(d[r]==C.get(r-1,0)-2*C[r]+C.get(r+1,0)for r in d) + assert any(C.values()) + return {'delta':{str(r):n for r,n in d.items()if n},'curvature':{str(r):n for r,n in C.items()if n},'count':sum(new.values()),'rank_mass':sum(r*n for r,n in new.items())} + +def main(): + baseline,local,invoice,out=map(Path,sys.argv[1:5]);old=json.loads(baseline.read_text())['nine']['profile'] + loc=json.loads(local.read_text());new=json.loads(invoice.read_text())['bit_profile'] + # Native legality receipt carries the actual regenerated frame-chain profile. + for key in ['paid_histogram','profile','paid_profile','histogram','rank_histogram']: + if key in loc:loc=loc[key];break + if isinstance(loc,list):loc=dict(loc) + if not all(str(k).isdigit()for k in loc):raise AssertionError(('unknown native histogram schema',list(loc))) + localold={1:1200,2:1440,4:180,6:120,8:9} + a=certificate(localold,loc);b=certificate(old,new) + assert a['curvature']=={'2':60} and b['curvature']=={'2':17280} + assert b['delta']=={r:288*n for r,n in a['delta'].items()} + controls=[] + for name,x,y in [('reverse',new,old),('missing_rank3',old,{**new,'3':int(new['3'])-1})]: + try:certificate(x,y) + except AssertionError:controls.append(name) + else:raise AssertionError(('control accepted',name)) + out.write_text(json.dumps({'status':'PASS_CURVATURE_CONE','local':a,'global':b,'negative_controls':controls},indent=2)+'\n') +if __name__=='__main__':main() diff --git a/research/trace-curvature-preload/code/build_preload60.py b/research/trace-curvature-preload/code/build_preload60.py new file mode 100644 index 0000000000..5a1b518a58 --- /dev/null +++ b/research/trace-curvature-preload/code/build_preload60.py @@ -0,0 +1,48 @@ +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +import json,gzip,hashlib,copy,sys,argparse +parser=argparse.ArgumentParser();parser.add_argument('--input',type=Path,required=True);parser.add_argument('--out',type=Path,required=True);args=parser.parse_args();src,out=args.input,args.out;w=json.loads(gzip.decompress(src.read_bytes()));V=w['v'];N=2*V+w['R'];old=copy.deepcopy(w);prefix=[];moves=[];A=[];assert hashlib.sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest()=='8639e22008c24a5690dd250eba702fe5fca85ddd036dcbec20baba77b7e213ba', 'pinned source word' +for i,(f,t,ss)in enumerate(w['A']): + if len(ss)==2 and all(sdim[a]:H[dim[f]-dim[a]]+=1 + cur[r]=f + def gates(sec): + for f,t,ss in z[sec]: + assert len({t,*ss})==1+len(ss) + for r in [t,*ss]:climb(r,f) + for s in ss:val[t]^=val[s] + gates('D');gates('A');tops.extend(dim[cur[q]]for q in z['ret']);snap=[val[q]for q in z['ret']] + for t,ks in enumerate(z['scatter']): + for k in ks:val[V+t]^=snap[k] + gates('B');gates('C') + for r,f in enumerate(z['final']):climb(r,f) + for r in range(N):assert val[r]==((1<=2*v;pending[s].append([f,t,[s]]) +assert all(not v<=r<2*v for f,t,ss in w['A']for r in [t]+ss) +a=[];delayed=0 +for e in w['A']: + for r in [e[1]]+e[2]: + if r in pending:a.extend(pending.pop(r));delayed+=1 + a.append(e) +assert not pending;z['D']=[];z['A']=a + +def chain(q): + hist=[[q['start'][r]]for r in range(n)] + for sec in ('D','A','B','C'): + for f,t,ss in q[sec]: + for r in [t]+ss: + if hist[r][-1]!=f:hist[r].append(f) + for r in range(n): + if hist[r][-1]!=q['final'][r]:hist[r].append(q['final'][r]) + return hist +assert chain(z)==chain(w) +def replay(q): + row=[1<= a(1-a) 3^(a-2) > 0. + +Consequently n such replacements lower the normalized moment by at least + + n a(1-a) 3^(a-2) / (W m^a). + +This is a uniform strict inequality for every admissible recurrence exponent, not a first-order entropy approximation or a fit at one floating-point value. The recurrence moment is strictly increasing as saving b=1-a increases, so its unique positive root strictly increases. The theorem does not authorize adding numeric kappa gains from separate constructions. + +## Concrete PR510-context application + +The PR510 R480 bit signature has 480 helpers, all width 8, 120 ports, m=64, 32 replicas, and nine complete calls per replica. The unchanged literal selection hosts every one of 138,240 residual occurrences and uses no banks. The changed source word moves 60 source additions to admissible early rank-one frames. Its exact local profile, including the nine rank-eight copies, is + + {1:1260, 2:1320, 3:60, 4:180, 6:120, 8:9}. + +Its local difference is 60(e_1-2e_2+e_3), hence the complete difference is 17,280(e_1-2e_2+e_3). The existing idle remainder multiset is retained. The new full profile is + + {1:362880, 2:395520, 3:17280, 4:67200, + 6:49920, 7:23040, 8:2592}. + +Live stock is 30,720 and the rank deficit is 9,984. Exact rational interval pricing with the inherited bad-class envelope gives + + 0.001589735702947998836661 < root < 0.001589735702947998836662. + +The left endpoint is a strict valid lower saving bound. This price is conditional on the changed finite native/physical/invoice checks, which are recorded separately by the main replay. It is not by itself a final assembled kappa. + +## Provenance and bounded alternatives + +The source analogy was the explicit endpoint-and-budget handoff in OAI's DirectedFeedback/Machines/MachineSubstitution.lean, notably stepAux_pushWord, statementPushBound_pushWord, and MachineSequential.compose. Its supplied theorem concerns Turing-machine composition, not multiplication suppliers. The weighted-gap organization in SoftChannel/JensenGaps.lean motivated retaining a quantitative gap; the elementary power-function proof above is proved here independently. Neither source was recompiled in this round. + +A separate bounded screen tested whole-width-eight controllers with seven through seventeen stages. Nine stages remained best. It also explains why merely enlarging the replica count cannot improve its fixed histogram: every rank-14, rank-28 and rank-42 idle bin is already maximally filled by width-eight residuals, leaving residues 6,4,2, while rank-seven bins cannot hold them. This bounded outcome does not exclude different providers, new interfaces, or different endpoint factorizations. + +## Completed changed-word finite replay + +The changed native local word and the nine-stage whole-owner physical pipeline subsequently passed. The independently reconstructed profile is exactly the displayed profile. All 17 parent mutations and 16 hosting mutations reject. There are 10,631,808 streamed events, 138,240 whole residual occurrences, and no bank assignments. The retained strict invoice gives prefix 193 bits charged at 256, a two-level coefficient of 425 bits charged at 512, row coefficient 18,355 below 20,161, and halving depth 2. Both independent rational moment engines certify the stated bit lower bound. These close the finite premises for this application under the explicitly retained all-size interfaces; the main package separately records outer assembly with the selected complex supplier. + +Direct public construction lineage is PR510 (nine-stage R480 price and whole residual selection), PR503 (dead-total R480 word), PR493 (bit carrier skeleton), PR463 (generalized stage pipeline), PR442/444 (whole residual hosting and audit), and PR386 (compressed nine-stage geometry). PR535 supplies the separately cited complex saving. The OpenAI source modules are mathematical provenance only, not hidden runtime dependencies. diff --git a/research/trace-curvature-preload/docs/CURVATURE-CONE.md b/research/trace-curvature-preload/docs/CURVATURE-CONE.md new file mode 100644 index 0000000000..1bcbd47f86 --- /dev/null +++ b/research/trace-curvature-preload/docs/CURVATURE-CONE.md @@ -0,0 +1,48 @@ +# A complete finite curvature calculus for profile comparison + +This is an elementary discrete-concavity theorem, proved here for the supplier interface. We do not claim it was unknown in mathematics. Its useful application is a proof certificate for an entire continuum of recurrence exponents and for every compatible future controller, rather than a floating-point price at one chosen exponent. + +## Theorem (curvature cone and constructive completeness) + +Let H and H' be finite nonnegative rank histograms supported on the integers 1,...,R. Set delta_r=H'_r-H_r. Assume both child count and rank mass agree: + + sum delta_r=0, sum r delta_r=0. + +For j=1,...,R put C_j=sum_{r0 and f is strictly concave at that index, the inequality is strict. This is a sufficient, explicitly computable criterion. It does not require knowing the eventual exponent or querying an optimization oracle. + +Proof. Difference the defining prefix sums twice to get the reconstruction formula. The mass and count identities give C_R=0 and the two right boundary identities. Substitute that second-difference expression into sum delta_r f(r), shift the finite summation indices, and cancel the zero boundary terms. Concavity proves A implies B. Conversely, fix an interior j and choose the concave function f_j(r)=-max(j-r,0). Its second difference is -1 at j and zero elsewhere. The displayed identity gives sum delta_r f_j(r)=-C_j. Property B therefore implies C_j>=0 for every j. All identities are finite exact rational arithmetic. QED. + +## Algebra of certificates + +Histograms compose by disjoint union. Thus a nonnegative integer sum of certified deltas has certificate equal to that same sum of their C vectors. If H0->H1 and H1->H2 are certified, H0->H2 is certified by C01+C12. A width-preserving provider substitution in N complete compatible contexts multiplies C by N. This gives a cone closed under program composition and substitution. It turns an optimizer's proposal into a short independently checkable quantitative proof. + +The theorem compares costs; it does not manufacture a legal word. The trace-refinement constructor and physical checks separately prove realizability. In particular C>=0 alone cannot replace a source-word, memory, ownership or scalar-prefix audit. + +## Strict improvement for the published recurrence interface + +Fix the same W,m and child count for both suppliers, with every used rank smaller than m. For 0 A X and leave Y unchanged. The old compensation is Y -> Y+D X. Then the exact identity + + [A on X] after [add D X to Y] + = [add (D A^{-1}) X to Y] after [A on X] + +holds on every input, including arbitrary helper dirt. Therefore compensation may be moved to another program cut by computing the inverse-version response D A^{-1}. One must factor the transported map into actual allowed scalar gates and check that every source and target frame can reach the chosen common frame and still reach their next uses. If those finite checks pass, the transformed program has precisely the same full scalar endpoint. It is not enough to compare clean-input columns or to reuse D without the inverse-version factor. + +For a sequence of elementary background gates, D A^{-1} is computed by the opposite column update, in the original prefix order. Thus this theorem supplies a constructive compiler pass with an exact rejection test. The untouched-register case gives a useful safe normal form: each dirty compensation read can be delayed up to the first instruction that touches its helper, while the target remains at frame zero. This special case needs no extra storage and preserves the frame-chain invoice. It is not claimed as an exponent improvement. `transport_compensation.py` implements this normal form on R480: all 480 helper dirt reads move to their last untouched versions, all 720 scalar columns agree exactly, and every deduplicated register frame chain is unchanged. The exact receipt is `transport-bit510/TRANSPORT.json`. This appendix does not claim a new native phase or global-program replay. + +## Bounded screens and scope + +On the original filtered504 source, 100 native nested-elimination trials were preserved; they reached up to 92 pivots and rank188, but became secondary when PR535 moved the frontier. No whole-profile gain is inferred from those counts. + +On the new binding R480 bit source, the exact post-center compensation screen rejected every individual helper under its specified first-B-frame schedule: 448 failed because a transported source frame was already above the target frame, and 23 failed the next-use containment test. The full transported compensator had 1273 incompatible support entries in that schedule. A separate exact screen of 120 additional non-root sum/difference lines, together with all 120 root lines, found no entry response circuit. These are bounded family failures, not a theorem excluding other cuts, joint cancellation, general frames, or other schedules. + +On PR535, all 112 post-center gauges already attain rank one in the intersection of their actual first frames, target first-use caps and donor-kernel caps. The remaining static census examined 27195 first-frame subspaces and found 12 nonzero-nullity line classes and no higher-rank candidate in that restricted interface. A bounded 100-seed presentation search yielded the checked 44-pivot witness above. No optimality claim follows. + +## Structural source references + +Mathlib's matrix transvection file supplies explicit left/right elementary update identities and reverse-inverse product identities. OpenAI's congruence elementary-matrix development supplies `clear_step`: an elementary update clears another entry while preserving an already-cleared prefix. We inspected these actual statements as structural models for the inductive invariant and product order. The new geometric compilation theorem and its changed provider were proved and checked here; they are not asserted to be direct imports or newly Lean-certified theorems. Exact source hashes are in META-SOURCES.json. diff --git a/research/trace-curvature-preload/docs/PR535-README.md b/research/trace-curvature-preload/docs/PR535-README.md new file mode 100644 index 0000000000..62abfa1591 --- /dev/null +++ b/research/trace-curvature-preload/docs/PR535-README.md @@ -0,0 +1,142 @@ +# Rank-four post-center kernels: a global κ delta from PR531 + +**Conditional global saving: `κ = 0.001584931111785787`.** This is +**4.42560686% above PR531** (`0.001517760977820331`) and **3.98391577% above +PR533**. The package is named `integer_mult_round21_rank4_delta` and contains +an incremental construction and its component evidence, using the scientifically +unchanged PR531 package as its baseline. + +| Quantity | Exact certified lower endpoint | +|---|---:| +| New complex supplier, rank-four kernel construction | `b = 0.001589991533606044174031` | +| Adopted PR510 bit supplier | `c = 0.001587447106092548137108` | +| Combined conditional global saving | **`κ = 0.001584931111785787`** | +| Control: new complex supplier with the former PR493 bit supplier | `κ = 0.001562995248531632` | + +The new complex supplier exceeds the old bit endpoint. The bit side now binds, +so the final composition adopts PR510's already published nine-stage R480 bit +supplier. Its exact rational endpoint is +`396861776523137034277 / 250000000000000000000000`. The PR493 control records +the gain available without this dependency change. The final κ is also +2.67486649% above the earlier post-center-only checkpoint. + +## New construction and adopted components + +The new contribution is by **icekylinx with GPT-6 Astra assistance**. It +composes post-center dirty compensation with larger response kernels: + +1. Helpers that are untouched by the source prefix and center cut still contain + exactly their initial dirt at the start of delivery. Their compensation can + therefore be performed there, after the center cut. +2. The 112 ordinary-M helpers form 14 disjoint groups of eight. Within each + group, four response columns span the other four, and all eight first native + frames contain a common frame of rank four. +3. Execute the retained gauge compensations first. Then inject each pivot into + its donors at the common rank-four frame. A donor may itself have been gauged: + the earlier compensation reads its original dirt, and the later injection + cancels the pivot's response without changing the donor's initial column. + +The scalar relations are exact, the frame containments are paid, and the new +source/helper operations are included in full-frame inverse cleanup. The word +retains 112 ports, 504 helpers, local dimension 9, and the existing center cut. +The original whole-call owner intervals remain in force. + +The entrance inventory is **40 rank-one kernel pivots, 112 rank-one gauges, +and 56 rank-four pivots**, for total entrance rank **376**. Residual widths are +**56 × 5, 152 × 8, and 296 × 9**. The coalesced local paid profile is + +```text +rank 1 2 3 4 5 6 8 +count 2208 728 184 280 56 56 8 +``` + +Its rank mass is **6016**. The global evidence includes actual whole-residual +owners, the paid invoice, and exact outer assembly; the reported κ is not +inferred from the local inventory alone. + +PR531 supplies the SAME504 scalar architecture, source/target geometry, +coalescing construction, and unchanged certificates. PR510 supplies the bit +rate and its conditional interfaces. **PR510's bit improvement is adopted and +credited; it is not presented as a new bit construction here.** No cold bit +replay was performed for this delta. PR533 is a numerical comparison source. + +## Fast incremental replay + +Provide the baseline package from PR531 at final head +`e07a8a3f9f79c22113398a0c5dbbc7601f489b3e`. Its relevant scientific files match +the original Round20 baseline pins. The baseline argument is the package +directory `research/direct-delivery504-global`, not the repository root. + +```sh +python -B replay_delta.py \ + --baseline /path/research/direct-delivery504-global \ + --work /tmp/rank4-check +``` + +Use a fresh work directory. The default mode reuses the completed phase evidence +bound to the packaged word and pinned baseline. The default replay uses the Python standard library. `--delta-phases` also +requires NumPy. Optional flags are: + +- `--rebuild-local`: reconstruct the changed local word. +- `--delta-phases`: repeat the targeted phase check for the changed frame pairs. + +For example: + +```sh +python -B replay_delta.py \ + --baseline /path/research/direct-delivery504-global \ + --work /tmp/rank4-check-rebuild \ + --rebuild-local --delta-phases +``` + +## Checks completed and their scope + +The component checks completed before packaging include exact scalar/frame +replay (**2.15 seconds**), the targeted phase delta (**2.29 seconds**), and +the independent check (**6.88 seconds**). Phase coverage consists of **126 new +frame pairs, 2801 pairs reused from bound baseline evidence, and 224 endpoint +adapters**. The new global owner/invoice checks and the combined exact outer +assembly passed. A separate small exact adjoint audit checks all 56 rank-four +response relations and every gauge-to-kernel-to-native frame containment. + +These timings describe completed component runs on the preparation machine. +The assembled `replay_delta.py` default wrapper passed end to end in +**22.71 seconds**, including all dependency bindings, the small rank-four +adjoint check, changed scalar/frame replay, actual owner reconstruction and +admission, fresh finite invoice, and both moments plus the 47 outer constraints. +See `evidence/fast-replay/RESULT.json`. The optional reconstruction and phase +flags have separate component evidence; they were not repeated by this wrapper run. The default fast mode also does not imply that predecessor +phase certificates or PR510's full bit pipeline were freshly rerun. + +## Conditional scope and sources + +This is a **finite conditional global witness**. It retains the all-size +compiler, common-label/mutable-basis and target-label realization, normalized +Lemma A realization, whole-call correlated-helper hosting, compressed-window, +restored-work, common-grid/tape, precision, row, and analytic transfer contracts. +The included PR510 carryover note explains why source-register writes use the +same role-independent address pullback at nine stages. It does not replace +those all-size assumptions with a finite scalar replay. No unconditional +multiplication theorem or Lean formalization is asserted. + +- [PR531: baseline SAME504 global construction](https://github.com/CrocSwap/integer-mult-bounds/pull/531). +- [PR510: adopted R480 nine-stage bit supplier](https://github.com/CrocSwap/integer-mult-bounds/pull/510), pinned to `64edee18af02aab0c1696b677a0287dd0146381b`. +- [PR510 pinned README and declared interfaces](https://github.com/DreamingOfClouds/integer-mult-bounds/blob/64edee18af02aab0c1696b677a0287dd0146381b/research/e8-r480-nine-stage/README.md). +- [PR493: former bit supplier and the mutable-source word](https://github.com/CrocSwap/integer-mult-bounds/pull/493). +- [PR484: attributed gauge/kernel primitives](https://github.com/CrocSwap/integer-mult-bounds/pull/484). +- [PR472: common-label and whole-call realization argument](https://github.com/CrocSwap/integer-mult-bounds/pull/472). +- [PR533: latest numerical comparison](https://github.com/CrocSwap/integer-mult-bounds/pull/533). + +The original PR531 and PR510 notices are retained separately. See `NOTICE.md` +and the packaged proof/evidence files for the contribution boundary and pins. + +## Submission validation + +The optional local reconstruction and changed-phase replay passed on Python +3.14.8 with NumPy 2.3.5 in 15.68 seconds. The intermediate checkpoint phase +delta was also freshly checked against the merged #531 baseline (194 edges), +followed by the final 126-edge delta. Independent emitted-program and all 21 +residual-wrapper checks passed. See `LOCAL-VALIDATION.json`. + +The submission starts from main at `f19cb621be2caf3a7291a37c343c1c55afe935e0`. +Logs remain outside the committed package and its manifest. diff --git a/research/trace-curvature-preload/docs/PRIVACY-ADAPTATIONS.json b/research/trace-curvature-preload/docs/PRIVACY-ADAPTATIONS.json new file mode 100644 index 0000000000..cb1322ba3b --- /dev/null +++ b/research/trace-curvature-preload/docs/PRIVACY-ADAPTATIONS.json @@ -0,0 +1,12 @@ +{ + "scope": "Only user-identifying attribution metadata is redacted from inherited explanatory files. PR numbers and head/source hashes are retained. Other upstream author attribution is retained. No numerical values or checker acceptance rules are changed. Historical subordinate manifests describe the original public trees; the root MANIFEST.json binds the actual adapted package.", + "changed_files": [ + "vendor/e8-bit-carrier-skeleton/NOTICE.md", + "vendor/e8-bit-carrier-skeleton/README.md", + "vendor/e8-bit-carrier-skeleton/SOURCE-pr471.json", + "vendor/e8-bit-carrier-skeleton/SOURCE-pr478.json", + "vendor/e8-bit-carrier-skeleton/SOURCE-pr483.json", + "vendor/e8-bit-carrier-skeleton/data/complex-b.json", + "vendor/e8-r480-dead-totals/README.md" + ] +} diff --git a/research/trace-curvature-preload/docs/PROVENANCE.md b/research/trace-curvature-preload/docs/PROVENANCE.md new file mode 100644 index 0000000000..2a0179ac67 --- /dev/null +++ b/research/trace-curvature-preload/docs/PROVENANCE.md @@ -0,0 +1,26 @@ +# Sources, attribution and adaptation + +The public refresh downloaded85 recent/updated PR conversations. New PR532-536 and the changed PR531 head were read. Changed-file trees were pinned for510,531-536. The strongest assembled claim in that snapshot was PR535, not PR536. The package is frozen to that snapshot and makes no live leaderboard claim. + +Direct numerical dependencies: + +- [PR535](https://github.com/CrocSwap/integer-mult-bounds/pull/535), head0d343e2f813f962405481f83d8935299812a7a1c: unchanged complex operator/profile/finite invoice; b=0.001589991533606044174031. +- [PR510](https://github.com/CrocSwap/integer-mult-bounds/pull/510), head64edee18af02aab0c1696b677a0287dd0146381b: nine-stage32-replica bit owner context. Our scalar word and resulting bit profile change. +- [PR503](https://github.com/CrocSwap/integer-mult-bounds/pull/503): R480 dead-total source word, as pinned inside510. +- [PR493](https://github.com/CrocSwap/integer-mult-bounds/pull/493): E8 bit carrier/native legality, all-column, mutable-source and prefix checks, as pinned inside510. + +Inherited implementation lineage: + +- [PR463](https://github.com/CrocSwap/integer-mult-bounds/pull/463): variable-stage global emitter and invoice. +- [PR442](https://github.com/CrocSwap/integer-mult-bounds/pull/442) and [PR444](https://github.com/CrocSwap/integer-mult-bounds/pull/444): literal whole-residual owner hosting. +- [PR386](https://github.com/CrocSwap/integer-mult-bounds/pull/386): nine-stage geometry. +- [PR531](https://github.com/CrocSwap/integer-mult-bounds/pull/531):504-helper complex foundation and exact assembly infrastructure. +- [PR533](https://github.com/CrocSwap/integer-mult-bounds/pull/533), [PR534](https://github.com/CrocSwap/integer-mult-bounds/pull/534), [PR536](https://github.com/CrocSwap/integer-mult-bounds/pull/536): response-presentation/frame-chain comparison; inspiration for the local-only appendix, not added final gains. + +Exact new/changed PR pins are in inputs/UPSTREAM-PINS.json. Vendored SOURCE files and licenses retain original authors, upstream hashes and subordinate lineage. No upstream C++ acceptance condition is weakened. The existing PR510 adapt.py retains its documented mutable-source compatibility and inapplicable-route-control adjustment; our wrapper invokes that same code. + +New code: commuting preload constructor, curvature certificate checker, orchestration, and source-bound exact composition. assemble_meta.py is adapted from the attributed PR535 assemble_combined.py: it consumes the fresh bit invoice while retaining pinned535complex receipts and the original rational engines. The verifier LF-normalizes a scratch copy before invoking scripts whose raw hashes matter. Generated gzip is deterministic. Upstream full-verifier entrypoints are retained for attribution, but not called because that would redundantly replay unrelated public stages. + +The cached nine-stage geometry is validated against all120label vectors and then by actual projector/route checks in the source-bound global pipeline. It is not trusted merely because its header says PASS. + +Source-read structural analogies are recorded with paths/declaration names/hashes in TRACE-SOURCES.json, CONTEXT-SOURCES.json and TRANSPORT-SOURCES.json. They include Mathlib transvections and the OpenAI ordered-product, machine-substitution, congruence-clearing and Jensen-gap developments. These were discovery guidance, not newly kernel-certified imports. No exhaustive-search or global-novelty claim is made. diff --git a/research/trace-curvature-preload/docs/RESEARCH.md b/research/trace-curvature-preload/docs/RESEARCH.md new file mode 100644 index 0000000000..e2ac24c0db --- /dev/null +++ b/research/trace-curvature-preload/docs/RESEARCH.md @@ -0,0 +1,13 @@ +# Preserved research and bounded outcomes + +The scalar trace and frame chains should be optimized together. The successful60-cell witness changes a representation while holding the full operator, boundary signature, residual widths, rank mass, child count and workspace fixed. The curvature vector detects a strict cost change that those aggregate invariants cannot detect. + +A first native screen of1,237,484complex insertion positions found no strict gain. Switching to the newly binding bit supplier screened1,431,669positions with1,388,956legal placements and68,400positive nominations. The exact60-cell batch passed independent rational/column checks. A second1,451,628-position single-move screen found no additional gain. This is a bounded neighborhood result, not optimality. + +Whole-width-eight stage profiles for7through17stages favored nine; seven was infeasible under this restricted whole-owner context. Scaling replica count alone does not improve its normalized profile. Alternative providers and schedules remain open. + +The response lane tested transport of dirty compensation to the post-center/pre-B cut. Its specified frame gate failed; this does not disprove other cuts or joint cancellations. Exact untouched-version transport was still constructed as a neutral 720-column example. A separate100-seed nested-response search yielded a40-to44static-pivot complex presentation, then full728-column checks in both orientations and44omission controls passed. It removes four rank-one children locally but needs complete new owner/physical admission before any independent complex bound may be claimed. The final kappa uses unchanged535complex. + +Four proof layers are included: trace equivalence with frame reassignment; complete-context resource substitution; a complete finite cone for all concave profile costs; and staged/versioned response compilation. They are not four independent exponent bonuses. Future workers can search for legal scalar/frame transformations whose profile differences lie in the proven cone, then reuse the same context theorem and finite pipeline. + +The promising next sufficient target is another concrete trace/frame rewrite or a complete version-transport factorization improving the binding bit profile while preserving the actual owner interface. Every proposed gain still needs a source word and its finite bill. No hypothetical gadget is treated as proved. diff --git a/research/trace-curvature-preload/docs/TRACE-REFINEMENT.md b/research/trace-curvature-preload/docs/TRACE-REFINEMENT.md new file mode 100644 index 0000000000..62096bee18 --- /dev/null +++ b/research/trace-curvature-preload/docs/TRACE-REFINEMENT.md @@ -0,0 +1,92 @@ +# Frame-sensitive trace refinement and the preload60 construction + +## Sufficient meta-theorem + +Let a finite reversible scalar program act on registers indexed by I over a field K. A scalar addition is T(t,s,q)=I+q e_t e_s^T, with t != s. Each register has an explicit initial frame, an explicit terminal frame, and a monotone chain of finite subspaces at its actual uses. Certain observation checkpoints (for example retained totals at a scatter) are fixed. + +Construct another program by the following certified operations: + +1. Factor a multi-source addition into elementary additions with the same destination and unchanged coefficients. +2. Permute elementary additions only through explicitly checked commuting gates, without crossing protected observation checkpoints. +3. Assign a new common frame to each relocated addition. Require that every touched register's predecessor frame is contained in it and that it is contained in that register's successor frame, including fixed initial, terminal and observation frames. +4. Rebuild the inverse background cleanup literally. Recompute every actual frame transition, retained-copy rank, scalar prefix bound and finite realization invoice. + +Then the new scalar program has exactly the same complete arbitrary-input endpoint. Its framed program satisfies the retained native frame-realization interface, and its exact recursive profile is the profile recomputed from those new chains, together with all retained-copy children. If the entrance and terminal signatures stay fixed, every old whole-owner allocation remains usable with unchanged residual-width and idle-remainder accounting. The changed physical finite realization still requires its actual phase/compiler and prefix checks; the theorem does not make those checks or inherited all-size hypotheses disappear. + +This is a calculus of representations of the SAME scalar word: it searches the trace-equivalence class and then selects a different legal frame labeling. A fixed event-order frame optimizer cannot expose every member of that class. A scalar-only optimizer cannot see the cost of its frame chains. Their joint finite certificate is the sufficient object. + +## Algebraic proof + +For t distinct from all s_i, the elementary additions to destination t commute, since e_(s_i)^T e_t=0. Hence + + I + sum_i q_i e_t e_(s_i)^T = product_i T(t,s_i,q_i). + +For distinct-source/destination elementary additions T(t,s,q) and T(u,v,r), the sufficient commuting condition is t != v and u != s. Expanding both products gives the same identity, two linear terms and zero cross terms. (There are further special commuting cases; they are not needed.) A scale on register u commutes with T(t,s,q) when u is neither t nor s. + +Every allowed adjacent exchange therefore preserves the entire linear operator. Induction on the explicit exchange list proves equality of the reordered body. It holds on arbitrary source, target and dirty-helper columns, not merely clean inputs. A word can be moved through a whole interval if it commutes with every gate crossed. Protected checkpoints are preserved because no move crosses them. + +If background updates do not read target registers, the background transformation is independent of targets. Reversing the order and inverting each actual new background gate gives its exact inverse, restoring all source/helper inputs. For an addition this negates its coefficient; over F2 the coefficient is unchanged. The body's target output is unchanged by the trace identity. Thus the full dirty-register endpoint is unchanged. Existing compensation can be retained because the body map itself, on every column, is unchanged. + +At a relocated instruction, the explicit predecessor/common/successor inclusions establish native frame legality. All other chains retain their previous inclusions. Applying the existing compiler interface to the actual changed word gives the same final labeled endpoint, with exactly the newly listed transition ranks. This last statement is conditional on that pre-existing all-size compiler interface; finite column replay is not an independent proof of the all-size interface. + +## Critical pair: splitting plus scheduling plus reframing + +Consider a two-source cell h += x+y first formed at a rank2 frame containing the rank1 source frames. Suppose its x addition commutes through the entire prefix, h initially has frame0, and the prefix does not observe h. Factor the gate into h += x followed by h += y. Move h += x to the beginning and perform it at x's rank1 frame. The later h += y remains at the original rank2 frame. + +The scalar map is identical. In the actual selected instance, the helper's former rank2 climb splits into two rank1 climbs. Meanwhile x no longer needs a formerly unique intermediate rank2 use between rank1 and rank4: its two climbs of ranks1 and2 coalesce into a rank3 climb. Therefore the net child-profile change is + + +delta1 - 2 delta2 + delta3. + +This is why neither a fixed-position scalar rewrite nor a fixed-order frame-coalescing pass alone finds the gain. The seam is moved before the frame assignment is simplified. The general theorem does not assume this particular delta: it always recomputes the actual changed chains. + +For every 0