diff --git a/research/h6-partial-frame-networks/CORE-SNAPSHOT.json b/research/h6-partial-frame-networks/CORE-SNAPSHOT.json new file mode 100644 index 0000000000..1153c56f29 --- /dev/null +++ b/research/h6-partial-frame-networks/CORE-SNAPSHOT.json @@ -0,0 +1,251 @@ +{ + "created_utc": "2026-10-20T21:56:25.102245+00:00", + "files": { + "FROZEN-SHA256.json": { + "bytes": 5591, + "sha256": "73c279f7f25a1e707fe1e3cd42e7d945c6c077d61dd252d54b70a5674361494c" + }, + "LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "ORIGINS.json": { + "bytes": 13177, + "sha256": "9b2de4b3353bc6bba6e336301b93034d6d935f3e769967f2b96932279e0d9126" + }, + "README.md": { + "bytes": 6952, + "sha256": "89a686562a54b7618f4418764d080456cd65d7ab737aa94c7c9faa2aa836e45c" + }, + "SOURCE-AUDIT.md": { + "bytes": 2121, + "sha256": "3d97ef7b57ec19840445506d8670cc48374b76b53369efab19f4228105699c6e" + }, + "SOURCES.json": { + "bytes": 3346, + "sha256": "1ec090de5cb3f24ede03b366aacc130bf2f0f785fada4a944d73aa087a7d6be6" + }, + "TASK.json": { + "bytes": 6361, + "sha256": "bb9cdf900a2b72dbf4bb26c87b3e9328226bc030cc0202df6a8a0ced7c5749e2" + }, + "VERIFY.json": { + "bytes": 1692, + "sha256": "cd4a861561b7ba5897a55cc1808d3513664b4bdb0d20515b3335cf219b9323a2" + }, + "controls.py": { + "bytes": 29074, + "sha256": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de" + }, + "cyclic/CHECKS.json.gz": { + "bytes": 585779, + "sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4" + }, + "cyclic/ORIGINS.json": { + "bytes": 6579, + "sha256": "e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617" + }, + "cyclic/OUTPUT-INVENTORY.json": { + "bytes": 3764, + "sha256": "fc95fed56a591960a14e787ac9438a5eea92dcfa266c22386f7e8db56ebc97fe" + }, + "cyclic/PACKAGE-FILES.json": { + "bytes": 1086, + "sha256": "1a80361230d10680487b5ec0f23b3dad93cc6e76a6435a2b016665e1b65ea723" + }, + "cyclic/PROOF-CYCLIC.md": { + "bytes": 17734, + "sha256": "1151cbf936040255969532590ee0c426e7035fc63e3ec7e9ee743031db31c830" + }, + "cyclic/VALIDATION.json": { + "bytes": 983, + "sha256": "4b21d22b09ccd1e6e4b7f689e84c25720ad2e4b68feaca59f092b6762029e02c" + }, + "cyclic/check.py": { + "bytes": 24562, + "sha256": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e" + }, + "cyclic/frozen/CONTINUATION.md": { + "bytes": 12614, + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + "cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz": { + "bytes": 26040, + "sha256": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44" + }, + "cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz": { + "bytes": 157656, + "sha256": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34" + }, + "cyclic/frozen/EXTENSION.md": { + "bytes": 14486, + "sha256": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7" + }, + "cyclic/frozen/K-RESULT.json": { + "bytes": 5462, + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841" + }, + "cyclic/frozen/MIXED-RECTANGLE-RESULT.json": { + "bytes": 23470, + "sha256": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8" + }, + "cyclic/frozen/MODULE-TILING-RESULT.json": { + "bytes": 22079, + "sha256": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590" + }, + "cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz": { + "bytes": 144986, + "sha256": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3" + }, + "cyclic/frozen/WALSH-RESULTS.json": { + "bytes": 10270, + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4" + }, + "cyclic/frozen/cyclic_mixed.py": { + "bytes": 8944, + "sha256": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a" + }, + "cyclic/frozen/dynamic_cyclic.py": { + "bytes": 8619, + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + "cyclic/frozen/e8_cubed.py": { + "bytes": 16408, + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + "cyclic/frozen/invoice.py": { + "bytes": 15168, + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef" + }, + "cyclic/frozen/mixed_rectangle.py": { + "bytes": 12779, + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + "cyclic/frozen/module_tiling.py": { + "bytes": 14507, + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + "cyclic/frozen/optimistic_budget.py": { + "bytes": 8995, + "sha256": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12" + }, + "cyclic/frozen/pricing.py": { + "bytes": 17909, + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454" + }, + "independent/CHECKS.json.gz": { + "bytes": 27080, + "sha256": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc" + }, + "independent/INDEPENDENT-INVENTORY.json": { + "bytes": 910, + "sha256": "1dd5f8673a3e2069ef7c6b4b5f7f640fe9b61d67a2808e87aabe0f9232f3ccbd" + }, + "independent/PROOF-INDEPENDENT.md": { + "bytes": 8868, + "sha256": "a933c6f3d89ac3ba648aea33453b6b1789719a5f42fc30b96de92afb38bb86c0" + }, + "independent/independent_operator.py": { + "bytes": 31769, + "sha256": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382" + }, + "notices/niemeier-NOTICE": { + "bytes": 4431, + "sha256": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562" + }, + "pauli/CHECKS.json.gz": { + "bytes": 265297, + "sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4" + }, + "pauli/ORIGINS.json": { + "bytes": 8671, + "sha256": "b4235680bf13f22e9bc408f074ad704b860dfee965876dfd005c4155d2d22382" + }, + "pauli/OUTPUT-INVENTORY.json": { + "bytes": 3104, + "sha256": "e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987" + }, + "pauli/PACKAGE-FILES.json": { + "bytes": 1005, + "sha256": "de43b271434680161972186463a7e57e8e9c20a230431c129fe393d268cc1fe4" + }, + "pauli/PROOF.md": { + "bytes": 20174, + "sha256": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c" + }, + "pauli/VALIDATION.json": { + "bytes": 2246, + "sha256": "da0f04c3415a432c6c235983789e6911bee467ab5dde80475d24e47e93e89184" + }, + "pauli/check.py": { + "bytes": 28675, + "sha256": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66" + }, + "pauli/frozen/CONTINUATION.md": { + "bytes": 12614, + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + "pauli/frozen/PARTIAL-PAULI-RESULT.json": { + "bytes": 29269, + "sha256": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0" + }, + "pauli/frozen/PARTIAL-PAULI-REVIEW.json": { + "bytes": 16729, + "sha256": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c" + }, + "pauli/frozen/PAULI-FIXED-SUPPORT.json": { + "bytes": 685, + "sha256": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9" + }, + "pauli/frozen/dynamic_cyclic.py": { + "bytes": 8619, + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + "pauli/frozen/e8_cubed.py": { + "bytes": 16408, + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + "pauli/frozen/e8_sections.py": { + "bytes": 19735, + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + "pauli/frozen/mixed_rectangle.py": { + "bytes": 12779, + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + "pauli/frozen/module_tiling.py": { + "bytes": 14507, + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + "pauli/frozen/partial_pauli.py": { + "bytes": 12954, + "sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd" + }, + "pauli/frozen/pauli_partial_review.py": { + "bytes": 15451, + "sha256": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad" + }, + "pauli/geometry.py": { + "bytes": 4858, + "sha256": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25" + }, + "reviews/CONTROLS.json": { + "bytes": 26205, + "sha256": "89c6364cfb3fa73ce1fb3f2c693c8e90a8ff171097e28bf383e88eeb6de2c2ac" + }, + "reviews/CROSS-REVIEW-PAULI-CHECK.json": { + "bytes": 2264, + "sha256": "569ac24b666e6260e5efab3f9a718c28e4e16a702ea1f7dcb22010fedafbfc8c" + }, + "reviews/CROSS-REVIEW-PAULI.md": { + "bytes": 8376, + "sha256": "64495b2300a2cc26aae124d156247f2e4d76f18595787b40529ca47dcf2f2974" + }, + "verify.py": { + "bytes": 7145, + "sha256": "db07043a36beac98813b35a9380cb2799dd0507348ab4aa62200ce65f9513c1b" + } + }, + "schema_version": 1, + "scope": "Publication candidate snapshot; mathematical and source-control reviews bind their declared source subsets. This record excludes itself and later review reports, to avoid circular hashes." +} diff --git a/research/h6-partial-frame-networks/FROZEN-SHA256.json b/research/h6-partial-frame-networks/FROZEN-SHA256.json new file mode 100644 index 0000000000..11d33e571d --- /dev/null +++ b/research/h6-partial-frame-networks/FROZEN-SHA256.json @@ -0,0 +1,58 @@ +{ + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "89a686562a54b7618f4418764d080456cd65d7ab737aa94c7c9faa2aa836e45c", + "SOURCE-AUDIT.md": "3d97ef7b57ec19840445506d8670cc48374b76b53369efab19f4228105699c6e", + "SOURCES.json": "1ec090de5cb3f24ede03b366aacc130bf2f0f785fada4a944d73aa087a7d6be6", + "TASK.json": "bb9cdf900a2b72dbf4bb26c87b3e9328226bc030cc0202df6a8a0ced7c5749e2", + "VERIFY.json": "cd4a861561b7ba5897a55cc1808d3513664b4bdb0d20515b3335cf219b9323a2", + "controls.py": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de", + "cyclic/CHECKS.json.gz": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4", + "cyclic/ORIGINS.json": "e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617", + "cyclic/OUTPUT-INVENTORY.json": "fc95fed56a591960a14e787ac9438a5eea92dcfa266c22386f7e8db56ebc97fe", + "cyclic/PACKAGE-FILES.json": "1a80361230d10680487b5ec0f23b3dad93cc6e76a6435a2b016665e1b65ea723", + "cyclic/PROOF-CYCLIC.md": "1151cbf936040255969532590ee0c426e7035fc63e3ec7e9ee743031db31c830", + "cyclic/VALIDATION.json": "4b21d22b09ccd1e6e4b7f689e84c25720ad2e4b68feaca59f092b6762029e02c", + "cyclic/check.py": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e", + "cyclic/frozen/CONTINUATION.md": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44", + "cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34", + "cyclic/frozen/EXTENSION.md": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7", + "cyclic/frozen/K-RESULT.json": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841", + "cyclic/frozen/MIXED-RECTANGLE-RESULT.json": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8", + "cyclic/frozen/MODULE-TILING-RESULT.json": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590", + "cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3", + "cyclic/frozen/WALSH-RESULTS.json": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4", + "cyclic/frozen/cyclic_mixed.py": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a", + "cyclic/frozen/dynamic_cyclic.py": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "cyclic/frozen/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "cyclic/frozen/invoice.py": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef", + "cyclic/frozen/mixed_rectangle.py": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "cyclic/frozen/module_tiling.py": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "cyclic/frozen/optimistic_budget.py": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12", + "cyclic/frozen/pricing.py": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454", + "independent/CHECKS.json.gz": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc", + "independent/INDEPENDENT-INVENTORY.json": "1dd5f8673a3e2069ef7c6b4b5f7f640fe9b61d67a2808e87aabe0f9232f3ccbd", + "independent/PROOF-INDEPENDENT.md": "a933c6f3d89ac3ba648aea33453b6b1789719a5f42fc30b96de92afb38bb86c0", + "independent/independent_operator.py": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382", + "notices/niemeier-NOTICE": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562", + "pauli/CHECKS.json.gz": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4", + "pauli/ORIGINS.json": "b4235680bf13f22e9bc408f074ad704b860dfee965876dfd005c4155d2d22382", + "pauli/OUTPUT-INVENTORY.json": "e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987", + "pauli/PACKAGE-FILES.json": "de43b271434680161972186463a7e57e8e9c20a230431c129fe393d268cc1fe4", + "pauli/PROOF.md": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c", + "pauli/VALIDATION.json": "da0f04c3415a432c6c235983789e6911bee467ab5dde80475d24e47e93e89184", + "pauli/check.py": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66", + "pauli/frozen/CONTINUATION.md": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "pauli/frozen/PARTIAL-PAULI-RESULT.json": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0", + "pauli/frozen/PARTIAL-PAULI-REVIEW.json": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c", + "pauli/frozen/PAULI-FIXED-SUPPORT.json": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9", + "pauli/frozen/dynamic_cyclic.py": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "pauli/frozen/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "pauli/frozen/e8_sections.py": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55", + "pauli/frozen/mixed_rectangle.py": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "pauli/frozen/module_tiling.py": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "pauli/frozen/partial_pauli.py": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "pauli/frozen/pauli_partial_review.py": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad", + "pauli/geometry.py": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25", + "verify.py": "db07043a36beac98813b35a9380cb2799dd0507348ab4aa62200ce65f9513c1b" +} diff --git a/research/h6-partial-frame-networks/LICENSE b/research/h6-partial-frame-networks/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/h6-partial-frame-networks/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/h6-partial-frame-networks/ORIGINS.json b/research/h6-partial-frame-networks/ORIGINS.json new file mode 100644 index 0000000000..3171ce8bbe --- /dev/null +++ b/research/h6-partial-frame-networks/ORIGINS.json @@ -0,0 +1,232 @@ +{ + "LICENSE": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "README.md": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "89a686562a54b7618f4418764d080456cd65d7ab737aa94c7c9faa2aa836e45c" + }, + "SOURCE-AUDIT.md": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "3d97ef7b57ec19840445506d8670cc48374b76b53369efab19f4228105699c6e" + }, + "SOURCES.json": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "1ec090de5cb3f24ede03b366aacc130bf2f0f785fada4a944d73aa087a7d6be6" + }, + "TASK.json": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "bb9cdf900a2b72dbf4bb26c87b3e9328226bc030cc0202df6a8a0ced7c5749e2" + }, + "VERIFY.json": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "cd4a861561b7ba5897a55cc1808d3513664b4bdb0d20515b3335cf219b9323a2" + }, + "controls.py": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de" + }, + "cyclic/CHECKS.json.gz": { + "original_sha256": "f06ada7495619759967cc1160a1012d8ed12e527970fd389717c4ef9b78cc832", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4" + }, + "cyclic/ORIGINS.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617" + }, + "cyclic/OUTPUT-INVENTORY.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "fc95fed56a591960a14e787ac9438a5eea92dcfa266c22386f7e8db56ebc97fe" + }, + "cyclic/PACKAGE-FILES.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "1a80361230d10680487b5ec0f23b3dad93cc6e76a6435a2b016665e1b65ea723" + }, + "cyclic/PROOF-CYCLIC.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "1151cbf936040255969532590ee0c426e7035fc63e3ec7e9ee743031db31c830" + }, + "cyclic/VALIDATION.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "4b21d22b09ccd1e6e4b7f689e84c25720ad2e4b68feaca59f092b6762029e02c" + }, + "cyclic/check.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e" + }, + "cyclic/frozen/CONTINUATION.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + "cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz": { + "original_sha256": "f65323e4d86d35f1463647ad36bddcffa21dc5eefc6ac4bbcbc8cf0ef4d0c369", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44" + }, + "cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz": { + "original_sha256": "9b9c02dac51d0989148c460f53623d51c6bd1204415991f058c83b77e36e884f", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34" + }, + "cyclic/frozen/EXTENSION.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7" + }, + "cyclic/frozen/K-RESULT.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841" + }, + "cyclic/frozen/MIXED-RECTANGLE-RESULT.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8" + }, + "cyclic/frozen/MODULE-TILING-RESULT.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590" + }, + "cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz": { + "original_sha256": "699abb5644ebc9ada64b67a6afd14ef9a418fab12a999430ee8296e0016d33db", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3" + }, + "cyclic/frozen/WALSH-RESULTS.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4" + }, + "cyclic/frozen/cyclic_mixed.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a" + }, + "cyclic/frozen/dynamic_cyclic.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + "cyclic/frozen/e8_cubed.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + "cyclic/frozen/invoice.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef" + }, + "cyclic/frozen/mixed_rectangle.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + "cyclic/frozen/module_tiling.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + "cyclic/frozen/optimistic_budget.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12" + }, + "cyclic/frozen/pricing.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454" + }, + "independent/CHECKS.json.gz": { + "original_sha256": "94645c9d913fb182b13cc03f17eb9cad3c056a5a8326c666739914636b8f0393", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc" + }, + "independent/INDEPENDENT-INVENTORY.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "1dd5f8673a3e2069ef7c6b4b5f7f640fe9b61d67a2808e87aabe0f9232f3ccbd" + }, + "independent/PROOF-INDEPENDENT.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "a933c6f3d89ac3ba648aea33453b6b1789719a5f42fc30b96de92afb38bb86c0" + }, + "independent/independent_operator.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382" + }, + "notices/niemeier-NOTICE": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562" + }, + "pauli/CHECKS.json.gz": { + "original_sha256": "dd2bd852b6b5b3c78f2e0cb6a5e6aff49cf4f3956aa18673bd555bfb6b069220", + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4" + }, + "pauli/ORIGINS.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "b4235680bf13f22e9bc408f074ad704b860dfee965876dfd005c4155d2d22382" + }, + "pauli/OUTPUT-INVENTORY.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987" + }, + "pauli/PACKAGE-FILES.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "de43b271434680161972186463a7e57e8e9c20a230431c129fe393d268cc1fe4" + }, + "pauli/PROOF.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c" + }, + "pauli/VALIDATION.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "da0f04c3415a432c6c235983789e6911bee467ab5dde80475d24e47e93e89184" + }, + "pauli/check.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66" + }, + "pauli/frozen/CONTINUATION.md": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + "pauli/frozen/PARTIAL-PAULI-RESULT.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0" + }, + "pauli/frozen/PARTIAL-PAULI-REVIEW.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c" + }, + "pauli/frozen/PAULI-FIXED-SUPPORT.json": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9" + }, + "pauli/frozen/dynamic_cyclic.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + "pauli/frozen/e8_cubed.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + "pauli/frozen/e8_sections.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + "pauli/frozen/mixed_rectangle.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + "pauli/frozen/module_tiling.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + "pauli/frozen/partial_pauli.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd" + }, + "pauli/frozen/pauli_partial_review.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad" + }, + "pauli/geometry.py": { + "provenance": "Component original source and transport inventories; parent-authored integration metadata", + "sha256": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25" + }, + "verify.py": { + "provenance": "Parent integration for the explicit C03 contribution", + "sha256": "db07043a36beac98813b35a9380cb2799dd0507348ab4aa62200ce65f9513c1b" + } +} diff --git a/research/h6-partial-frame-networks/README.md b/research/h6-partial-frame-networks/README.md new file mode 100644 index 0000000000..f739abdb99 --- /dev/null +++ b/research/h6-partial-frame-networks/README.md @@ -0,0 +1,52 @@ +# Cyclic H6 readers and paid partial-centre visits + +This package gives exact logical H6 subfamily circuits, a complete disjoint root-product tiling with its expensive residual completion, and two partial-frame replacements for eight existing Pauli centres. It exposes two cost tradeoffs: fewer scalar operations can worsen the recursive rank profile, and cheaper private copies can require more source, target and helper visits. + +All ordinary source, target and helper inputs are arbitrary. The checked words restore ordinary helper **logical values at declared final frames**. Helpers move from ZERO to FULL; raw physical return to their entrance frames is not proved. Binary frame incidences, exact scalar operators, private-stream contracts and physical compiler admission are distinct obligations. + +For `r=2,...,7`, `N=2r`, mutable cyclic readers cost `N(54r-1)` forward and `N(54r+2)` inverse-transpose component primitives, compared with `N(72r-37)` and `N(72r-34)` for the static predecessor. Real and imaginary components are charged separately. Both pay rank mass `83N`. The mutable word saves `18N(r-2)` component primitives, but its rank-profile pressure is strictly worse for `r=3,...,7` at equal stock and arity, for every exponent `0= 3; the L = 1 capped bill is not claimed. + +[Cyclic proof](cyclic/PROOF-CYCLIC.md) and [Pauli proof](pauli/PROOF.md) give the assumptions, operators, complete profiles and exact covered domains. Complete deterministic receipts and the separate mathematical audit accompany the checkers. The rank/Smith theorems already published in [PR3649](https://github.com/CrocSwap/integer-mult-bounds/pull/3649) and [PR3655](https://github.com/CrocSwap/integer-mult-bounds/pull/3655) are outside this contribution. + +## Reproduction + +Run the registered standard-library Python 3.12 package from the repository root: + +``` +python3.12 scripts/research_package.py --package research/h6-partial-frame-networks +``` + +The same commands run directly from a Git-free export, with an absolute package path: + +``` +python3.12 -I -O -B /absolute/export/research/h6-partial-frame-networks/verify.py --stage cyclic +python3.12 -I -O -B /absolute/export/research/h6-partial-frame-networks/verify.py --stage pauli +python3.12 -I -O -B /absolute/export/research/h6-partial-frame-networks/verify.py --stage independent +python3.12 -I -B /absolute/export/research/h6-partial-frame-networks/controls.py --package /absolute/export/research/h6-partial-frame-networks +``` + + Each stage writes temporary replay files outside the package, authenticates the executed source buffers and compares every field of the regenerated typed JSON receipt. Gzip transport bytes do not determine mathematical equality. The package-local source inventories and `SOURCES.json` retain original Git pins and unpublished source bytes; no private workspace is required at runtime. + +## Scope and limits + +The cyclic operators are exhaustive finite ordinary-column checks on the stated r2..7 families; the tiled geometry exhausts 2,400 binary frame cases and 4,800 signed modules. The Pauli full-support factor identity and schedule are written proofs supported by finite geometry and arbitrary-input diagnostic operators. The static/mutable comparison is an all-exponent written argument for the fixed profiles. These are not formal-kernel proofs. + +Private work uses the inherited cleared COPY/descent/scatter/ERASE interface. The full K factor and full-H6 support counts remain explicitly inherited pinned evidence. Source/target frame representatives, Clifford phases, raw physical helper return, coefficient temporary states, rounded precision, approximate children, physical banks, owner allocation, tape/controller costs and all-size transfer remain open. No complete favorable H6 supplier, compatible BIT supplier, new kappa, selected-frontier change or unrestricted lower bound is claimed. + +## Open next questions + +Can a full dynamic incidence network replace the large residual edge bank? A useful first step is one complete overlap-aware source/helper/target itinerary with its whole stock and rank histogram; the present disjoint modules do not provide it. + +Can another factor network share enough partial-centre visits to improve the complete moment? Start with actual support spans, target-cap inclusions and a paid chronology. The present comparison covers only the selected eight-centre group and the specified tiling. + +Can a complete logical word receive physical and rounded recursive admission? Bind actual frame and phase recipes first, then price raw returns, coefficient temporaries, numerical error, storage and access. [TASK.json](TASK.json) records these questions and their blockers. + +## Sources and credit + +Scientific inputs are pinned to `20ecf2891d80b5acf18d980b2164fb44ea7faa90`; repository guidance is pinned to `12fa8c5c844be21bfefb38a19503fbd867a11244`, priority 7. Credit Dominik Scholz / PR606 for the H6 geometry, DreamingOfClouds for the H6/Walsh proposal, and the PR1830 compensation/encoder audit with its retained predecessor lineage. Original unpublished C03 scripts, receipts and their exact adaptations are identified in the source inventories. Historical notes retain their original limits and are not fresh acceptance of unrelated claims. + +Ross Richardson, with substantial OpenAI Codex assistance, including separate AI mathematical review contexts. That review is not independent human or formal-kernel acceptance. Apache-2.0; the original [Niemeier source notice](notices/niemeier-NOTICE) retains its geometry, Clifford-frame, common-frame and supplier ancestry. diff --git a/research/h6-partial-frame-networks/SOURCE-AUDIT.md b/research/h6-partial-frame-networks/SOURCE-AUDIT.md new file mode 100644 index 0000000000..0b8ba0517a --- /dev/null +++ b/research/h6-partial-frame-networks/SOURCE-AUDIT.md @@ -0,0 +1,33 @@ +# Source and evidence boundary + +Scientific inputs are pinned to `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +`SOURCES.json` records the originating Git blobs, including the task card at +`12fa8c5c844be21bfefb38a19503fbd867a11244`. All runtime data are package-local. +The two component `ORIGINS.json` files identify original unpublished C03 bytes +and captured Git dependencies; original receipts use gzip transport where +needed, with exact uncompressed hashes retained. Historical notes are provenance, +not fresh validation of stronger claims they may contain. + +The cyclic adapter preserves the five historical programs and their mathematical +predicates. It substitutes captured loaders and external output paths, binds the +inherited K constants to pinned records, and adds complete ordinary-column +matrices. It compares every original mathematical receipt field. The Pauli audit +is a fresh standard-library reconstruction from the preserved geometry and +selected polynomial columns; its written source binding does not reexecute the +entire NumPy factorization. The independent checker separately reconstructs +operators by reverse covectors and prefixes by integer-dyadic rows. Its source +imports neither producer checker. + +This contribution adds the completed finite logical cyclic words, disjoint +module tiling, exact scalar/rank tradeoff, selected eight-centre interfaces, and +one fully paid construction sharing their visits. The noncubic-rank theorem of +PR3649 and Smith/repair theorem of PR3655 are excluded. The full-H6 pairing +census and 816-centre background remain inherited evidence; the residual +completion is counted and specified, not emitted as a billion-event execution. + +The root frozen inventory authenticates executed source, retained inputs and +expected receipts. The three stages compare complete typed JSON and reconcile +the same 2400 frame cases and ordered geometry. These checks protect the stated +scope; they are not a signature, formal proof kernel, native phase compiler, +raw physical helper-return proof, rounded recursive implementation or new kappa. +Separate AI reviews are disclosed as such. diff --git a/research/h6-partial-frame-networks/SOURCES.json b/research/h6-partial-frame-networks/SOURCES.json new file mode 100644 index 0000000000..2760adbf50 --- /dev/null +++ b/research/h6-partial-frame-networks/SOURCES.json @@ -0,0 +1,73 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "docs/research/research-family-status.md", + "usage": "provenance", + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f" + }, + { + "path": "research/h6-independent-audit/invoice/verify.py", + "usage": "provenance", + "git_blob": "0fb65580f8d88d450be2411a49a507461288e4e8", + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/h6-independent-audit/invoice/verify.py" + }, + { + "path": "research/h6-compensation-network/k_encoder/RESULT.json", + "usage": "provenance", + "git_blob": "31368ec6d6eac0d0cb86b0d17c80f07b092d75ff", + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/h6-compensation-network/k_encoder/RESULT.json" + }, + { + "path": "research/h6-compensation-network/pricing/verify.py", + "usage": "provenance", + "git_blob": "f9434ab83e11a4e93d92fdf1b2a9d7f008b41232", + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/h6-compensation-network/pricing/verify.py" + }, + { + "path": "research/h6-independent-audit/walsh/results.json", + "usage": "provenance", + "git_blob": "4f7a9294c96b6ba69a28527c980f24d696369929", + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/h6-independent-audit/walsh/results.json" + }, + { + "path": "research/niemeier-lattices/code/e8_cubed.py", + "usage": "provenance", + "git_blob": "d4444d142fb370498bcd9a0abec45e2f5ea0b0c5", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/niemeier-lattices/code/e8_cubed.py" + }, + { + "path": "research/niemeier-lattices/code/e8_sections.py", + "usage": "provenance", + "git_blob": "b9d6fb3a39c330414965601d1aa5faf80f0a36c6", + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/niemeier-lattices/code/e8_sections.py" + }, + { + "path": "research/niemeier-lattices/NOTICE", + "usage": "provenance", + "git_blob": "e6dcbd0c683ca877031fdaefd5803f6e4cf5ac78", + "sha256": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/niemeier-lattices/NOTICE" + } + ] +} diff --git a/research/h6-partial-frame-networks/TASK.json b/research/h6-partial-frame-networks/TASK.json new file mode 100644 index 0000000000..d1f4d2bcf2 --- /dev/null +++ b/research/h6-partial-frame-networks/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Complete source-bound H6 cyclic and partial-Pauli logical network words, exact arbitrary-dirt forward/inverse-transpose operators, nested binary frame itineraries, complete paid profile comparisons, and a bounded visit-sharing construction.", + "scope_change_reason": "Explicit user assignment to finish C03 from unpublished preserved contributions. The changed H6 geometry has its own coverage law; this scoped interface completion does not meet or claim the selected P112 supplier-budget target.", + "bottleneck_link": "Mutable readers reduce scalar operations but change recursive rank profiles. Partial centre returns save private ranks only after all source, target and ordinary helper visits are charged.", + "budget_minutes": 240, + "stop_rule": "Authenticate and replay the finite r2..7 cyclic words and disjoint r3 tiling; complete the selected eight-centre Pauli interfaces and their one bounded shared-visit comparison. Stop at exact cost comparison or incompatibility, without a larger network synthesis.", + "outcome": "partial", + "evidence": "cyclic/PROOF-CYCLIC.md, pauli/PROOF.md, independent/PROOF-INDEPENDENT.md; complete CHECKS.json.gz receipts and source-bound package controls.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance, including separate AI mathematical review contexts; no independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Can a full H6 dynamic compensation network replace the expensive residual edge readers?", + "why_it_matters": "The disjoint six-port modules cover only a small subset of the nonzero compensation entries; their fallback remains expensive.", + "first_step": "Give one complete overlap-aware source/helper/target itinerary and compute its whole rank histogram, stock and remaining coverage.", + "blocked_by": "No favorable full incidence network or compatible owner allocation is supplied." + }, + { + "question": "Can a different factor network share enough Pauli visits to improve the complete moment?", + "why_it_matters": "Private-copy savings alone omit added data and helper transitions.", + "first_step": "Use exact source support and target-cap inclusions to construct a complete shared itinerary, then price the changed profile.", + "blocked_by": "The checked constructions cover the selected eight-centre feature group and the specified disjoint tiling only." + }, + { + "question": "Can these logical words be admitted as physical rounded recursive suppliers?", + "why_it_matters": "Logical coefficient restoration at changed endpoint frames is not raw physical return or a precision/storage/controller proof.", + "first_step": "Bind a complete word to actual phase-correct frame recipes and derive all physical returns, coefficient temporaries, numerical error and storage costs.", + "blocked_by": "Native phase lowering, physical ownership/access, rounding and a matching BIT supplier remain open." + } + ] +} diff --git a/research/h6-partial-frame-networks/VERIFY.json b/research/h6-partial-frame-networks/VERIFY.json new file mode 100644 index 0000000000..833a9256f2 --- /dev/null +++ b/research/h6-partial-frame-networks/VERIFY.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "cyclic" + ], + "timeout_seconds": 180, + "checks": "All r2..7 cyclic forward/dual ordinary maps, complete invoices, actual frames, 4800 disjoint modules and counted residual completion; exact finite profiles and defect controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "pauli" + ], + "timeout_seconds": 180, + "checks": "All 5760 support ports, actual U15/W2 and 2400 shared tiling cases, four diagnostic operators and the fully paid shared-visit histograms; rigorous rational signs and mutation controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent" + ], + "timeout_seconds": 90, + "checks": "Separate reverse-covector operators and integer-dyadic prefixes, full frame/invoice comparisons, factored pairing certificate, and named semantic gate-deletion controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py", + "--package", + "{package}" + ], + "timeout_seconds": 90, + "checks": "Authenticated captured-source execution, complete typed records, exact stage coverage and shared geometry, optimization and output-path defects, with check-deletion sensitivities." + } + ] +} diff --git a/research/h6-partial-frame-networks/controls.py b/research/h6-partial-frame-networks/controls.py new file mode 100644 index 0000000000..7d80aab5a0 --- /dev/null +++ b/research/h6-partial-frame-networks/controls.py @@ -0,0 +1,567 @@ +#!/usr/bin/env python3 +"""Compact C03 source, record, shared-geometry and semantic gate controls. + +Adapted from the independently reviewed C02 source controls. All mutated +files use fresh system temporary directories. No full science stage runs. +Substantial OpenAI Codex assistance; Apache-2.0. +""" + + +import argparse +import ast +import copy +import gzip +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import types + +def require(ok, message): + if not ok: + raise ValueError(message) + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def load_module(path, raw=None, name="reviewed_controls_module"): + source = path.read_bytes() if raw is None else raw + module = types.ModuleType(name) + module.__file__ = str(path) + exec(compile(source, str(path), "exec", dont_inherit=True, optimize=0), module.__dict__) + return module + +def reject(label, action, expected, records, exact=True): + try: + action() + except (ValueError, AssertionError) as error: + message = str(error) + require(message == expected if exact else expected in message, + "wrong rejection for " + label + ": " + message) + records.append({"name": label, "intended_gate": expected}) + else: + raise ValueError("control accepted: " + label) + +def fixture(root, files, originals=None): + root.mkdir(parents=True) + hashes, origins = {}, {} + for name, raw in files.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + hashes[name] = sha(raw) + origins[name] = {"sha256": sha(raw)} + if originals and name in originals: + origins[name]["original_sha256"] = sha(originals[name]) + (root / "FROZEN-SHA256.json").write_text(json.dumps(hashes)) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + return root + +def loader_checks(v, temporary): + positive = ( + b"import json, sys\nfrom pathlib import Path\n" + b"assert __debug__ and sys.flags.optimize == 0, 'CHILD_OPTIMIZATION'\n" + b"assert __file__ == sys.argv[0], 'SCRIPT_FILE_ARGUMENT'\n" + b"Path(sys.argv[-1]).write_text(json.dumps(sys.argv[1:-1]))\n" + ) + files = { + "script with spaces.py": positive, + "direct.py": b"assert False, 'DIRECT_ASSERT'\n", + "nested.py": b"def inner():\n assert False, 'NESTED_ASSERT'\ninner()\n", + "notfinite.json": b'{"a":NaN}', + } + root = fixture(temporary / "loader", files) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + output = temporary / "literal argument result.json" + frozen.run("script with spaces.py", ["argument with spaces", output]) + require(json.loads(output.read_text()) == ["argument with spaces"], "preserved script arguments") + for name, marker in (("direct.py", "DIRECT_ASSERT"), ("nested.py", "NESTED_ASSERT")): + reject(name, lambda name=name: frozen.run(name, []), + "AssertionError: " + marker, rejected, exact=False) + # This disposable source is changed only after Frozen.raw has returned. + # The script passed to the interpreter must remain the captured old bytes. + original_path, calls = frozen.path, {"count": 0} + def changed_path(name): + path = original_path(name) + calls["count"] += 1 + if calls["count"] == 2: + path.write_bytes(b"raise RuntimeError('REOPENED_CHANGED_SOURCE')\n") + return path + frozen.path = changed_path + try: + frozen.run("script with spaces.py", ["captured bytes", output]) + require(calls["count"] == 2 and json.loads(output.read_text()) == ["captured bytes"], + "captured authenticated source execution") + finally: + frozen.path = original_path + (root / "script with spaces.py").write_bytes(positive) + (root / "direct.py").write_bytes(b"PASS = True\n") + reject("changed_executable_source", lambda: frozen.run("direct.py", []), + "changed frozen input: direct.py", rejected) + (root / "direct.py").unlink() + reject("missing_executable_source", lambda: frozen.run("direct.py", []), + "missing regular input: direct.py", rejected) + reject("unregistered_source", lambda: frozen.run("absent.py", []), + "unregistered input: absent.py", rejected) + reject("absolute_path", lambda: frozen.path("/etc/passwd"), "unsafe package path", rejected) + reject("parent_escape", lambda: frozen.path("../outside"), "unsafe package path", rejected) + (root / "link.py").symlink_to(root / "nested.py") + reject("symlink_input", lambda: frozen.path("link.py"), + "missing regular input: link.py", rejected) + outside = temporary / "external" + outside.mkdir() + (outside / "data.json").write_text("{}") + (root / "outside").symlink_to(outside, target_is_directory=True) + reject("ancestor_symlink_escape", lambda: frozen.path("outside/data.json"), + "input escapes package", rejected) + reject("direct_runtime_requirement", lambda: v.require(False, "DIRECT_RUNTIME_GATE"), + "DIRECT_RUNTIME_GATE", rejected) + return {"rejections": rejected, "captured_source_survives_disposable_path_change": True, + "child_assertions_enabled": True, "file_and_argument_semantics_preserved": True} + +def record_checks(v, temporary): + value = {"integer": 1, "boolean": True, "nested": {"ordered": [1, 2, 3]}} + raw = json.dumps(value).encode() + root = fixture(temporary / "record", {"expected.json": raw}) + frozen, rejected = v.Frozen(root), [] + frozen.compare("expected.json", raw) + mutations = { + "boolean_for_integer": dict(value, integer=True), + "float_for_integer": dict(value, integer=1.0), + "integer_for_boolean": dict(value, boolean=1), + "nested_omission": dict(value, nested={}), + "ordered_list_reorder": dict(value, nested={"ordered": [1, 3, 2]}), + "ordered_list_truncate": dict(value, nested={"ordered": [1, 2]}), + } + for label, changed in mutations.items(): + reject(label, lambda changed=changed: frozen.compare("expected.json", json.dumps(changed).encode()), + "complete typed record mismatch: expected.json", rejected) + reject("duplicate_json_key", lambda: v.data(b'{"a":1,"a":2}'), + "duplicate JSON key: a", rejected) + reject("nested_duplicate_json_key", lambda: v.data(b'{"n":{"a":1,"a":2}}'), + "duplicate JSON key: a", rejected) + for value_ in ("NaN", "Infinity", "-Infinity"): + reject("nonfinite_" + value_, lambda value_=value_: v.data(value_.encode()), + "nonfinite JSON constant: " + value_, rejected) + (root / "expected.json").unlink() + reject("missing_expected_record", lambda: frozen.compare("expected.json", raw), + "missing regular input: expected.json", rejected) + require(not (root / "expected.json").exists(), "missing expected record regenerated") + (root / "expected.json").write_bytes(raw) + saved = v.require + try: + v.require = lambda ok, message: None if message.startswith("complete typed record mismatch:") else saved(ok, message) + try: + reject("deleted_record_gate", + lambda: frozen.compare("expected.json", json.dumps(mutations["boolean_for_integer"]).encode()), + "complete typed record mismatch: expected.json", []) + except ValueError as error: + require(str(error) == "control accepted: deleted_record_gate", "record check-deletion sensitivity") + else: + raise ValueError("record check deletion not detected") + finally: + v.require = saved + return {"rejections": rejected, "named_record_gate_deletion_detected": True} + +def compression_checks(v, temporary): + name, plain = "original.json.gz", b'{"original":[1,2,3]}\n' + root = fixture(temporary / "compression", {name: gzip.compress(plain, mtime=0)}, {name: plain}) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + changed = gzip.compress(b'{"original":[1,2,4]}\n', mtime=0) + (root / name).write_bytes(changed) + reject("changed_compressed_input", frozen.check_all, + "changed frozen input: " + name, rejected) + frozen.hashes[name] = sha(changed) + reject("changed_container_origin", frozen.check_all, + "origin digest mismatch: " + name, rejected) + frozen.origins[name]["sha256"] = sha(changed) + reject("changed_original_after_transport_rebinding", frozen.check_all, + "original decoded bytes changed: " + name, rejected) + same = gzip.compress(plain, mtime=17) + (root / name).write_bytes(same) + frozen.hashes[name] = frozen.origins[name]["sha256"] = sha(same) + frozen.check_all() + saved = frozen.origins + frozen.origins = {} + reject("omitted_origin", frozen.check_all, "frozen/origin inventory mismatch", rejected) + frozen.origins = saved + return {"rejections": rejected, "equivalent_recompression_accepted": True} + + +STAGES = ('cyclic', 'pauli', 'independent') + + +def deletion(v, action, gate): + saved = v.require + try: + v.require = lambda ok, message: None if message == gate else saved(ok, message) + try: + reject('deleted_'+gate, action, gate, []) + except ValueError as error: + require(str(error) == 'control accepted: deleted_'+gate, 'intended check deletion') + else: + raise ValueError('deleted gate still rejected: '+gate) + finally: + v.require = saved + + +def real_records(v, package): + frozen, records = v.Frozen(package), [] + names = sorted(set().union(*(v.expected_records(stage) for stage in STAGES))) + def leaves(value, path=()): + if isinstance(value, dict): + for key in sorted(value): + yield from leaves(value[key], path+(key,)) + elif isinstance(value, list): + for i, child in enumerate(value): + yield from leaves(child, path+(i,)) + else: + yield path, value + for name in names: + raw = frozen.raw(name) + value = v.data(raw) + frozen.compare(name, json.dumps(value).encode()) + path, old = max(leaves(value), key=lambda item: len(item[0])) + require(len(path) > 1, 'real nested record coverage') + changed, omitted = copy.deepcopy(value), copy.deepcopy(value) + parent, other = changed, omitted + for key in path[:-1]: + parent, other = parent[key], other[key] + parent[path[-1]] = not old if type(old) is bool else old+1 if type(old) is int else {'changed': True} + del other[path[-1]] + rejected = [] + for label, candidate in (('deep_field_changed', changed), ('deep_field_omitted', omitted)): + reject(label, lambda candidate=candidate: frozen.compare(name, json.dumps(candidate).encode()), + 'complete typed record mismatch: '+name, rejected) + records.append({'record': name, 'sha256': sha(raw), 'nested_path': list(path), 'rejections': rejected}) + require(len(records) == 3, 'three complete scientific records') + return records + + +def coverage_checks(v, temporary): + require(set(v.STAGES) == set(STAGES), 'exact three science stages') + rejected, counts = [], {} + for stage in STAGES: + names = sorted(v.expected_records(stage)) + v.check_coverage(stage, names) + counts[stage] = len(names) + for label, changed in (('omitted', []), ('duplicated', names+names), ('extra', names+['extra.json'])): + reject(stage+'_'+label, lambda stage=stage, changed=changed: v.check_coverage(stage, changed), + 'complete stage record coverage changed: '+stage, rejected) + require(counts == dict.fromkeys(STAGES, 1), 'three singleton complete records') + + class Tiny: + def __init__(self, omit=False): + self.root, self.compared, self.scripts, self.omit = temporary, [], [], omit + def raw(self, name): + require(name in ('cyclic/CHECKS.json.gz', 'pauli/CHECKS.json.gz'), 'only declared dependent records read') + return gzip.compress(b'{}', mtime=0) + def path(self, name): + return self.root/name + def run(self, script, arguments): + self.scripts.append(script) + require(arguments.count('--output') == 1, 'one external output argument') + output = Path(arguments[arguments.index('--output')+1]) + require(output.is_relative_to(temporary), 'dispatch external scratch') + if script.startswith('independent/'): + require(Path(arguments[arguments.index('--source-dir')+1]) == self.root/'cyclic/frozen', + 'independent historical source argument') + for label, name in (('cyclic', 'cyclic/CHECKS.json.gz'), ('pauli', 'pauli/CHECKS.json.gz')): + require(Path(arguments[arguments.index('--'+label+'-receipt')+1]) == self.root/name, + 'independent full receipt argument') + require(arguments[arguments.index('--'+label+'-sha256')+1] == sha(self.raw(name)), + 'independent receipt digest comes from authenticated bytes') + else: + require(arguments == ['--output', output], 'direct production checker arguments') + output.write_text('{}') + def compare(self, name, raw): + require(raw == b'{}', 'generated fixture reaches complete comparison') + if not self.omit: + self.compared.append(name) + + for stage in STAGES: + scratch = temporary/('dispatch-'+stage) + scratch.mkdir() + tiny = Tiny() + v.replay(tiny, scratch, stage) + v.check_coverage(stage, tiny.compared) + require(tiny.scripts == [v.STAGES[stage][0]], 'one declared checker selected') + scratch = temporary/'dispatch-omitted-compare' + scratch.mkdir() + tiny = Tiny(True) + v.replay(tiny, scratch, 'pauli') + action = lambda: v.check_coverage('pauli', tiny.compared) + gate = 'complete stage record coverage changed: pauli' + reject('omitted_actual_compare', action, gate, rejected) + deletion(v, action, gate) + return {'rejections': rejected, 'stage_counts': counts, 'real_dispatch_covered_with_tiny_receipts': True, + 'executed_check_deletions': 1} + + +def contract_checks(v, package): + frozen = v.Frozen(package) + original = {name: v.data(frozen.raw(name)) for name in ('cyclic/CHECKS.json.gz', 'pauli/CHECKS.json.gz')} + baseline = v.check_contracts(frozen) + class Candidate: + def __init__(self, values): + self.values = values + def raw(self, name): + return json.dumps(self.values[name]).encode() + rejected = [] + definitions = [('frame_array_changed', 'complete tiling frame arrays differ'), + ('frame_scalar_type_changed', 'complete tiling frame arrays differ'), + ('frame_order_changed', 'complete tiling frame arrays differ'), + ('frame_count_both_truncated', 'complete tiling frame count'), + ('declared_digest_changed', 'complete tiling frame digest mismatch')] + definitions += [('shared_'+key, 'complete shared geometry differs: '+key) for key in ( + 'canonical_roots', 'a_triples', 'b_orthogonal_involution_pairs', 'triple_gauge_signs')] + key_map = {'canonical_roots': 'canonical_roots', 'a_triples': 'tiling_a_triples', + 'b_orthogonal_involution_pairs': 'tiling_b_pairs', 'triple_gauge_signs': 'tiling_gauge_signs'} + for name, gate in definitions: + changed = copy.deepcopy(original) + left = changed['cyclic/CHECKS.json.gz']['complete_tiling']['frame_cases'] + p = changed['pauli/CHECKS.json.gz'] + right = p['tiling_frame_cases'] + if name == 'frame_array_changed': + right[0]['labels'][0] ^= 1 + elif name == 'frame_scalar_type_changed': + right[0]['labels'][0] = True + elif name == 'frame_order_changed': + right[0], right[1] = right[1], right[0] + elif name == 'frame_count_both_truncated': + left.pop(); right.pop() + p['tiling_frame_cases_sha256'] = sha(v.canonical(left).encode()) + elif name == 'declared_digest_changed': + p['tiling_frame_cases_sha256'] = '0'*64 + else: + p[key_map[name.removeprefix('shared_')]][0][0] += 1 + action = lambda changed=changed: v.check_contracts(Candidate(changed)) + reject(name, action, gate, rejected) + deletion(v, action, gate) + return {'rejections': rejected, 'authenticated_original_contract': baseline, + 'mutations_after_authentication': True, 'executed_check_deletions': len(definitions)} + + +def scientific_gates(v, package, temporary): + from fractions import Fraction + frozen, rejected = v.Frozen(package), [] + cyclic = load_module(package/'cyclic/check.py', frozen.raw('cyclic/check.py')) + modules, _, _ = cyclic.authenticated_modules(package/'cyclic/frozen', package/'cyclic/ORIGINS.json', temporary) + m = modules['mixed_rectangle.py'] + receipt = v.data(frozen.raw('cyclic/CHECKS.json.gz')) + fix = receipt['reports']['DYNAMIC-CYCLIC-RESULT.json']['cases'][1]['fixture'] + # The source fixture serializes tuple frames to lists. Restore that declared representation only. + fix = copy.deepcopy(fix) + fix['starts'] = {k: tuple(x) for k, x in fix['starts'].items()} + fix['ends'] = {k: tuple(x) for k, x in fix['ends'].items()} + m.replay(fix) + gate = 'all-column exact identity with arbitrary dirt' + action = lambda: m.replay(fix, False, 'comp_restore') + reject('cyclic_actual_dirty_helper_cleanup', action, gate, rejected) + cyclic.deletion_control(m, action, gate) + gate = 'equal current frames' + action = lambda: m.replay(fix, False, 'source_read_arc') + reject('cyclic_actual_source_frame', action, gate, rejected) + cyclic.deletion_control(m, action, gate) + paid = copy.deepcopy(fix) + first = next(e for e in paid['events'] if e['op'] == 'add') + paid['events'][:0] = [dict(first, q='1'), dict(first, q='-1')] + result = m.replay(paid) + require(cyclic.operator_difference(result, False) is None, 'actual paid pair preserves cyclic operator') + gate = 'complete scalar invoice' + action = lambda: cyclic.accept_bill(result, 'dynamic', 3, False) + reject('cyclic_actual_paid_cancelling_pair', action, gate, rejected) + deletion(cyclic, action, gate) + + pauli = load_module(package/'pauli/check.py', frozen.raw('pauli/check.py')) + pauli.m = pauli.load_geometry(frozen.raw('pauli/geometry.py')) + case = v.data(frozen.raw('pauli/CHECKS.json.gz'))['cases'][1] + pfix = copy.deepcopy(case['fixture']) + pfix['starts'] = {k: tuple(x) for k, x in pfix['starts'].items()} + pfix['ends'] = {k: tuple(x) for k, x in pfix['ends'].items()} + pfix['K'] = [[Fraction(x) for x in row] for row in pfix['K']] + pauli.replay(pfix) + for tag, gate in (('cleanup', 'all arbitrary input and dirty centre columns'), + ('target_W', 'literal equal common frame')): + action = lambda tag=tag: pauli.replay(pfix, False, tag) + reject('pauli_actual_'+tag, action, gate, rejected) + outcome = pauli.rejection('compact_'+tag, action, gate) + require(outcome['named_guard_deletion'] == 'ACCEPTED', 'actual Pauli gate deletion') + return {'rejections': rejected, 'executed_check_deletions': 5, + 'ordinary_corruption_tests_after_source_authentication': True, + 'one_r3_and_one_radical_diagnostic_only': True, 'full_science_stages_replayed': False} + + +def source_checks(v, package, temporary): + frozen, rejected = v.Frozen(package), [] + cyclic = load_module(package/'cyclic/check.py', frozen.raw('cyclic/check.py')) + pauli = load_module(package/'pauli/check.py', frozen.raw('pauli/check.py')) + reject('nested_geometry_assertion', lambda: pauli.load_geometry( + b"def nested():\n assert False, 'GEOMETRY_NESTED_ASSERT'\nnested()\n"), + 'GEOMETRY_NESTED_ASSERT', rejected) + require(pauli.load_geometry(b'assert __debug__\nCAPTURED=713\n').CAPTURED == 713, + 'explicit geometry captured bytes execute with assertions') + source_dir = temporary/'cyclic sources' + source_dir.mkdir() + manifest_raw = frozen.raw('cyclic/ORIGINS.json') + manifest = json.loads(manifest_raw) + manifest_path = temporary/'cyclic origins.json' + manifest_path.write_bytes(manifest_raw) + for row in manifest['files']: + name = row.get('transport_path', row['path']) + (source_dir/name).write_bytes(frozen.raw('cyclic/frozen/'+name)) + call = lambda: cyclic.authenticated_modules(source_dir, manifest_path, temporary) + manifest_path.write_bytes(manifest_raw+b' ') + reject('changed_nested_manifest', call, 'source manifest SHA256', rejected) + manifest_path.write_bytes(manifest_raw) + invoice = source_dir/'invoice.py' + invoice_raw = invoice.read_bytes() + invoice.write_bytes(invoice_raw+b"\ndef nested_control():\n assert False, 'RETAINED_NESTED_ASSERT'\nnested_control()\n") + reject('changed_retained_executable', call, 'authenticated source bytes: invoice.py', rejected) + for row in manifest['files']: + if row['path'] == 'invoice.py': + row['bytes'], row['sha256'] = len(invoice.read_bytes()), sha(invoice.read_bytes()) + rebound = json.dumps(manifest).encode() + manifest_path.write_bytes(rebound) + old_pin = cyclic.ORIGINS_SHA + cyclic.ORIGINS_SHA = sha(rebound) + try: + reject('retained_nested_assertion_with_disposable_pin', call, 'RETAINED_NESTED_ASSERT', rejected) + finally: + cyclic.ORIGINS_SHA = old_pin + invoice.write_bytes(invoice_raw) + manifest_path.write_bytes(manifest_raw) + # The actual production loader has captured every input before its first + # ModuleType creation. Mutate a disposable source at that exact cut. + original_type = cyclic.types.ModuleType + created = [] + def mutate_after_capture(name): + if not created: + invoice.write_bytes(b"raise RuntimeError('PATH_REOPENED_AFTER_AUTHENTICATION')\n") + created.append(name) + return original_type(name) + cyclic.types.ModuleType = mutate_after_capture + try: + modules, captured, adaptations = call() + require(captured['invoice.py'] == invoice_raw and len(modules) == 6, + 'retained loader executes captured original bytes') + finally: + cyclic.types.ModuleType = original_type + invoice.write_bytes(invoice_raw) + reject('duplicate_literal_adapter_match', lambda: cyclic.replace_once('x x', 'x', 'y'), + 'unique source adaptation', rejected) + + pauli_dir = temporary/'pauli inputs' + for name in pauli.PINS: + target = pauli_dir/name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(frozen.raw('pauli/'+name)) + output = temporary/'no Pauli result.json' + argv, pins = sys.argv, pauli.PINS.copy() + def invoke(): + sys.argv = ['check.py', '--inputs', str(pauli_dir), '--output', str(output)] + pauli.main() + target = pauli_dir/'frozen/module_tiling.py' + original = target.read_bytes() + try: + target.write_bytes(original+b'\nTRIPLES = []\n') + reject('changed_selected_literal_source', invoke, 'authenticated source bytes', rejected) + pauli.PINS['frozen/module_tiling.py'] = sha(target.read_bytes()) + reject('duplicate_selected_TRIPLES', invoke, 'unique frozen TRIPLES assignment', rejected) + tree = ast.parse(original) + assign = next(n for n in tree.body if isinstance(n, ast.Assign) + and any(isinstance(x, ast.Name) and x.id == 'TRIPLES' for x in n.targets)) + lines = original.decode().splitlines(keepends=True) + target.write_text(''.join(lines[:assign.lineno-1]+lines[assign.end_lineno:])) + pauli.PINS['frozen/module_tiling.py'] = sha(target.read_bytes()) + reject('missing_selected_TRIPLES', invoke, 'unique frozen TRIPLES assignment', rejected) + finally: + sys.argv, pauli.PINS = argv, pins + require(not output.exists(), 'failed source control emitted no scientific receipt') + return {'rejections': rejected, 'retained_module_count': len(modules), + 'retained_compile_optimization': [x['optimize'] for x in adaptations], + 'actual_captured_loader_survives_disposable_source_change': True, + 'no_path_import_or_pyc_execution_used': True, 'full_science_stages_replayed': False} + + +def output_checks(v, package, temporary): + rejected, argv = [], sys.argv + existing = temporary/'existing result' + existing.write_text('preserved') + def invoke(output): + sys.argv = ['verify.py', '--stage', 'cyclic', '--output', str(output)] + v.main() + try: + reject('relative_wrapper_output', lambda: invoke(Path('relative-output.json')), + 'output must be absolute', rejected) + reject('existing_wrapper_output', lambda: invoke(existing), 'output already exists', rejected) + reject('internal_wrapper_output', lambda: invoke(package/'forbidden-output.json'), + 'output must be external', rejected) + finally: + sys.argv = argv + require(existing.read_text() == 'preserved', 'existing output retained') + return {'rejections': rejected, 'guards_precede_scientific_replay': True} + + +def child(package): + v = load_module(package/'verify.py') + v.Frozen(package).check_all() + with tempfile.TemporaryDirectory(prefix='C03 compact controls ') as directory: + temporary = Path(directory) + result = {'loader': loader_checks(v, temporary), 'record_gate': record_checks(v, temporary), + 'compression': compression_checks(v, temporary), 'coverage': coverage_checks(v, temporary), + 'contracts': contract_checks(v, package), 'scientific_gates': scientific_gates(v, package, temporary), + 'nested_sources': source_checks(v, package, temporary), + 'output': output_checks(v, package, temporary), 'real_records': real_records(v, package)} + v.Frozen(package).check_all() + return {'parent_optimization': sys.flags.optimize, **result} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--package', type=Path, required=True) + parser.add_argument('--output', type=Path) + parser.add_argument('--child', action='store_true') + args = parser.parse_args() + package = args.package.resolve() + if args.output: + require(args.output.is_absolute(), 'control output must be absolute') + require(not args.output.exists(), 'control output already exists') + require(not args.output.resolve().is_relative_to(package), 'control output must be external') + if args.child: + print(json.dumps(child(package), sort_keys=True)) + return + names = ['verify.py', 'FROZEN-SHA256.json', 'ORIGINS.json', 'cyclic/check.py', 'pauli/check.py', + 'pauli/geometry.py', 'independent/independent_operator.py'] + before = {name: sha((package/name).read_bytes()) for name in names} + results = [] + for optimized in (False, True): + command = [sys.executable, '-I', '-B']+(['-O'] if optimized else []) + command += [str(Path(__file__).resolve()), '--package', str(package), '--child'] + completed = subprocess.run(command, capture_output=True, text=True) + require(completed.returncode == 0, completed.stdout+completed.stderr) + results.append(json.loads(completed.stdout)) + require(before == {name: sha((package/name).read_bytes()) for name in names}, 'reviewed source changed during controls') + comparable = [{k: value for k, value in result.items() if k != 'parent_optimization'} for result in results] + require(comparable[0] == comparable[1], 'normal and optimized controls differ') + count = sum(len(s.get('rejections', [])) for s in results[0].values() if isinstance(s, dict)) + count += sum(len(s['rejections']) for s in results[0]['real_records']) + deletions = 1+sum(s.get('executed_check_deletions', 0) for s in results[0].values() if isinstance(s, dict)) + result = {'status': 'PASS_C03_COMPACT_SOURCE_RECORD_AND_SEMANTIC_CONTROLS', + 'source_hashes': before, 'control_source_sha256': sha(Path(__file__).read_bytes()), + 'runs': results, 'normal_and_optimized_receipts_equal_except_mode': True, + 'intended_rejections_per_mode': count, 'executed_check_deletions_per_mode': deletions, + 'full_scientific_receipts_compared': 3, 'full_scientific_stages_replayed': False, 'no_new_kappa': True} + if args.output: + with args.output.open('x') as handle: + handle.write(json.dumps(result, sort_keys=True, indent=2)+'\n') + print(json.dumps({k: result[k] for k in ('status', 'intended_rejections_per_mode', + 'executed_check_deletions_per_mode', 'full_scientific_receipts_compared')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/cyclic/CHECKS.json.gz b/research/h6-partial-frame-networks/cyclic/CHECKS.json.gz new file mode 100644 index 0000000000..e89ee8655a Binary files /dev/null and b/research/h6-partial-frame-networks/cyclic/CHECKS.json.gz differ diff --git a/research/h6-partial-frame-networks/cyclic/ORIGINS.json b/research/h6-partial-frame-networks/cyclic/ORIGINS.json new file mode 100644 index 0000000000..02b416dfeb --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/ORIGINS.json @@ -0,0 +1,142 @@ +{ + "files": [ + { + "bytes": 12779, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/mixed_rectangle.py", + "path": "mixed_rectangle.py", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + { + "bytes": 8944, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/cyclic_mixed.py", + "path": "cyclic_mixed.py", + "sha256": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a" + }, + { + "bytes": 8619, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/dynamic_cyclic.py", + "path": "dynamic_cyclic.py", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + { + "bytes": 14507, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/module_tiling.py", + "path": "module_tiling.py", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + { + "bytes": 8995, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/optimistic_budget.py", + "path": "optimistic_budget.py", + "sha256": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12" + }, + { + "bytes": 14486, + "kind": "historical_note_provenance_only", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/EXTENSION.md", + "path": "EXTENSION.md", + "sha256": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7" + }, + { + "bytes": 12614, + "kind": "historical_note_provenance_only", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CONTINUATION.md", + "path": "CONTINUATION.md", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + { + "bytes": 1461095, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/DYNAMIC-CYCLIC-RESULT.json", + "path": "DYNAMIC-CYCLIC-RESULT.json", + "sha256": "9b9c02dac51d0989148c460f53623d51c6bd1204415991f058c83b77e36e884f", + "transport": "gzip", + "transport_bytes": 157656, + "transport_path": "DYNAMIC-CYCLIC-RESULT.json.gz", + "transport_sha256": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34" + }, + { + "bytes": 751544, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CYCLIC-MIXED-RESULT.json", + "path": "CYCLIC-MIXED-RESULT.json", + "sha256": "f65323e4d86d35f1463647ad36bddcffa21dc5eefc6ac4bbcbc8cf0ef4d0c369", + "transport": "gzip", + "transport_bytes": 26040, + "transport_path": "CYCLIC-MIXED-RESULT.json.gz", + "transport_sha256": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44" + }, + { + "bytes": 23470, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/MIXED-RECTANGLE-RESULT.json", + "path": "MIXED-RECTANGLE-RESULT.json", + "sha256": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8" + }, + { + "bytes": 22079, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/MODULE-TILING-RESULT.json", + "path": "MODULE-TILING-RESULT.json", + "sha256": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590" + }, + { + "bytes": 849067, + "kind": "historical_original", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/OPTIMISTIC-BUDGET-RESULT.json", + "path": "OPTIMISTIC-BUDGET-RESULT.json", + "sha256": "699abb5644ebc9ada64b67a6afd14ef9a418fab12a999430ee8296e0016d33db", + "transport": "gzip", + "transport_bytes": 144986, + "transport_path": "OPTIMISTIC-BUDGET-RESULT.json.gz", + "transport_sha256": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3" + }, + { + "bytes": 15168, + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "kind": "executed_oracle_functions", + "origin": "research/h6-independent-audit/invoice/verify.py", + "path": "invoice.py", + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef" + }, + { + "bytes": 5462, + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "kind": "inherited_K_inventory", + "origin": "research/h6-compensation-network/k_encoder/RESULT.json", + "path": "K-RESULT.json", + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841" + }, + { + "bytes": 17909, + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "kind": "provenance_only", + "origin": "research/h6-compensation-network/pricing/verify.py", + "path": "pricing.py", + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454" + }, + { + "bytes": 10270, + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "kind": "inherited_all_pairs_receipt", + "origin": "research/h6-independent-audit/walsh/results.json", + "path": "WALSH-RESULTS.json", + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4" + }, + { + "bytes": 16408, + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "kind": "geometry_provenance", + "origin": "research/niemeier-lattices/code/e8_cubed.py", + "path": "e8_cubed.py", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + } + ], + "schema": "c03_cyclic_sources.v1", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90" +} diff --git a/research/h6-partial-frame-networks/cyclic/OUTPUT-INVENTORY.json b/research/h6-partial-frame-networks/cyclic/OUTPUT-INVENTORY.json new file mode 100644 index 0000000000..c41c36e102 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/OUTPUT-INVENTORY.json @@ -0,0 +1,122 @@ +{ + "files": [ + { + "bytes": 585779, + "path": "CHECKS.json.gz", + "sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4" + }, + { + "bytes": 6579, + "path": "ORIGINS.json", + "sha256": "e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617" + }, + { + "bytes": 1086, + "path": "PACKAGE-FILES.json", + "sha256": "1a80361230d10680487b5ec0f23b3dad93cc6e76a6435a2b016665e1b65ea723" + }, + { + "bytes": 17734, + "path": "PROOF-CYCLIC.md", + "sha256": "1151cbf936040255969532590ee0c426e7035fc63e3ec7e9ee743031db31c830" + }, + { + "bytes": 983, + "path": "VALIDATION.json", + "sha256": "4b21d22b09ccd1e6e4b7f689e84c25720ad2e4b68feaca59f092b6762029e02c" + }, + { + "bytes": 24562, + "path": "check.py", + "sha256": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e" + }, + { + "bytes": 12614, + "path": "frozen/CONTINUATION.md", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + { + "bytes": 26040, + "path": "frozen/CYCLIC-MIXED-RESULT.json.gz", + "sha256": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44" + }, + { + "bytes": 157656, + "path": "frozen/DYNAMIC-CYCLIC-RESULT.json.gz", + "sha256": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34" + }, + { + "bytes": 14486, + "path": "frozen/EXTENSION.md", + "sha256": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7" + }, + { + "bytes": 5462, + "path": "frozen/K-RESULT.json", + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841" + }, + { + "bytes": 23470, + "path": "frozen/MIXED-RECTANGLE-RESULT.json", + "sha256": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8" + }, + { + "bytes": 22079, + "path": "frozen/MODULE-TILING-RESULT.json", + "sha256": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590" + }, + { + "bytes": 144986, + "path": "frozen/OPTIMISTIC-BUDGET-RESULT.json.gz", + "sha256": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3" + }, + { + "bytes": 10270, + "path": "frozen/WALSH-RESULTS.json", + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4" + }, + { + "bytes": 8944, + "path": "frozen/cyclic_mixed.py", + "sha256": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a" + }, + { + "bytes": 8619, + "path": "frozen/dynamic_cyclic.py", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + { + "bytes": 16408, + "path": "frozen/e8_cubed.py", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + { + "bytes": 15168, + "path": "frozen/invoice.py", + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef" + }, + { + "bytes": 12779, + "path": "frozen/mixed_rectangle.py", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + { + "bytes": 14507, + "path": "frozen/module_tiling.py", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + { + "bytes": 8995, + "path": "frozen/optimistic_budget.py", + "sha256": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12" + }, + { + "bytes": 17909, + "path": "frozen/pricing.py", + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454" + } + ], + "inventory_excludes_itself": true, + "schema": "c03_cyclic_frozen_inventory.v1", + "status": "FROZEN" +} diff --git a/research/h6-partial-frame-networks/cyclic/PACKAGE-FILES.json b/research/h6-partial-frame-networks/cyclic/PACKAGE-FILES.json new file mode 100644 index 0000000000..a6bada1965 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/PACKAGE-FILES.json @@ -0,0 +1,35 @@ +{ + "excluded_preserved_development": [ + "validation/", + "frozen/REPORT.md", + "uncompressed duplicates of gzip historical receipts" + ], + "files": [ + "CHECKS.json.gz", + "ORIGINS.json", + "OUTPUT-INVENTORY.json", + "PACKAGE-FILES.json", + "PROOF-CYCLIC.md", + "VALIDATION.json", + "check.py", + "frozen/CONTINUATION.md", + "frozen/CYCLIC-MIXED-RESULT.json.gz", + "frozen/DYNAMIC-CYCLIC-RESULT.json.gz", + "frozen/EXTENSION.md", + "frozen/K-RESULT.json", + "frozen/MIXED-RECTANGLE-RESULT.json", + "frozen/MODULE-TILING-RESULT.json", + "frozen/OPTIMISTIC-BUDGET-RESULT.json.gz", + "frozen/WALSH-RESULTS.json", + "frozen/cyclic_mixed.py", + "frozen/dynamic_cyclic.py", + "frozen/e8_cubed.py", + "frozen/invoice.py", + "frozen/mixed_rectangle.py", + "frozen/module_tiling.py", + "frozen/optimistic_budget.py", + "frozen/pricing.py" + ], + "notes": "Historical notes are provenance only. Full original source and receipt bytes remain recoverable; gzip transport keeps exact raw hashes.", + "schema": "c03_cyclic_package_files.v1" +} diff --git a/research/h6-partial-frame-networks/cyclic/PROOF-CYCLIC.md b/research/h6-partial-frame-networks/cyclic/PROOF-CYCLIC.md new file mode 100644 index 0000000000..d43af2b41d --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/PROOF-CYCLIC.md @@ -0,0 +1,349 @@ +# Cyclic mixed readers on fixed H6 subfamilies + +This package replays exact common-frame words for actual H6 subfamilies with +`r=2,...,7`, compares two reader schedules, and reconstructs 4,800 disjoint +six-port modules on the 28,800 root-product ports. The positive result is a +logical arbitrary-input circuit with checked binary frame incidences. It +does not provide the missing physical phase/adapter compiler, a rounded +supplier, a physical ownership schedule, or a new multiplication bound. + +The source geometry/factorization is credited to Dominik Scholz / PR606; +the alternate H6/Walsh proposal to DreamingOfClouds / Discussion1167; and +the complete compensation/encoder audit to PR1830 and its predecessor +lineage. The retained local constructions are `mixed_rectangle.py`, +`cyclic_mixed.py`, `dynamic_cyclic.py`, and `module_tiling.py` from the +historical complex-alternative investigation. All are preserved byte for +byte in `frozen/`. Substantial OpenAI Codex assistance; Apache-2.0 ancestry. +The scientific Git pin is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +`ORIGINS.json` records every original and dependency byte hash. + +## Exact input and frame contract + +Scalars lie in `Z[1/2]`, acting on arbitrary complex vectors. Every ordinary +source x, target y, K centre c, and compensation reader h is arbitrary and +independent; correlated inputs are consequently allowed. Private streams +alone have the separately stipulated cleared-work interface. + +The address space is the actual 17-bit binary space. A frame is represented +by a canonical binary row basis. A CLIMB must move from a contained +subspace to a containing subspace. ADDs require exactly the same current +basis on source and destination. Sources begin at their actual rank-one +address lines; y, c, and h begin at ZERO. Sources, c, and h finish at FULL; +y finishes at the rank-sixteen cap perpendicular to its address. + +The replay tracks logical coefficients relative to those declared frames. +Thus restored c and h mean their initial logical values at the specified +final FULL frames. They do **not** mean raw physical return to the initial +ZERO-frame representatives. Historical statements using “literal +restoration” must be read with this correction. No choice of actual +Clifford representatives, no global phase identification, and no free +physical adapter is proved by a binary subspace inclusion. + +The new receipt preserves full ordinary-column matrices, every emitted +event, each register's rank path, and exact logical prefix norms and dyadic +denominator depths. There are `4N` independent ordinary columns in each +cyclic case, `N=2r`, and fourteen in the precursor rectangle. This is a +coefficient proof for arbitrary ordinary inputs, not testing random inputs. + +## Geometry and coefficients of the cyclic family + +In ordinary E8 coordinates choose `a_g=e_0-e_(g+1)`, +`beta=e_0+e_1`, and `gamma=e_0-e_1`. The two ports in group g are +`(a_g,beta)` and `(a_g,gamma)`. The programs retain doubled integer +coordinates, the exact cubic kernel + +``` +K_ij = (t_ij^3 - 4 t_ij)/48, C = I-K, +C = (J_r-I_r) tensor (1/16)[[-5,1],[1,-5]]. +``` + +The exceptional Gram-three coefficient is therefore included. The +source-faithful binary fit constructs the 17-bit labels and verifies +their parity against every actual Gram entry in each fixture. For each +group let U_g be the plane spanned by its two labels. Define cyclic arcs + +``` +F(g,k) = U_g + ... + U_(g+k-1), 1 <= k <= r-1. +``` + +The exact finite geometry verifies dimension `k+1`, inclusion in both +target caps of group `g+k`, and nesting of consecutive arcs. Source +group j has nested inclusive visits `F(j-d,d+1)`, for +`d=0,...,r-2`. These are actual subspace checks on the retained labels, +not dimension-only promises. The construction covers exactly `r=2,...,7`; +an abstract use at other sizes would first need these same hypotheses. + +The eigenvalues of C are `-(r-1)/4`, `1/4`, `-3(r-1)/8`, and `3/8`, +with multiplicities 1, r-1, 1, r-1, respectively. They are nonzero and +none is one. Hence both C and the restricted `K=I-C` have full rank N. +The rank test here is specific to these displayed block matrices; it is +separate from the published odd-polynomial and Smith results, which this +package neither reproduces nor claims as new. + +## Complete mutable-reader word + +Allocate two dirty readers per group, initially `h_g^+=d_g^+` and +`h_g^-=d_g^-`. At depth d, advance that pair to `F(g,d+1)` and advance +source group `g+d` to the same frame. Perform the four unit signed ADDs + +``` +h_g^+ += x_(g+d,0) + x_(g+d,1), +h_g^- += x_(g+d,0) - x_(g+d,1). +``` + +This executes real successive reads of original source groups. Every +source is unchanged as a logical value, and its visits are nested. After +`r-1` reads, reader g contains all sources except group `g-1` in its two +signed channels. All sources then reach FULL. + +Only target pair `t=g-1` receives reader g. Its decoder is + +``` +y_(t,0) += -h_g^+/8 - 3h_g^-/16, +y_(t,1) += -h_g^+/8 + 3h_g^-/16. +``` + +Before either target leaves ZERO, subtract these same decoder coefficients +of the original reader dirt. Writing L for the accumulated input mixing +and R for this decoder gives exactly `RL=C` on every coefficient. + +The intervening restricted-K word is also explicit. At ZERO precompensate +`y -= Kc`; move each ordinary c to FULL and gather `c += x`. For each +centre, create a cleared private stream, copy c, descend privately to ZERO, +scatter its actual K column, and clear the private stream. Undo the centre +gathers at FULL. All targets remain at ZERO through this step. This pays N +ordinary centres and N separate rank-seventeen private episodes; it is not +an unpriced clean-input K macro. + +Each target then climbs once to the final reader arc, receives its decoder +contribution, and finishes its cap climb. Each h climbs to FULL and +subtracts exactly the original source combination it accumulated. Algebra +on all ordinary columns gives + +``` +(x,y,c,d) -> (x, y+(K+RL)x, c, d) = (x,y+x,c,d). +``` + +The static predecessor instead loads each reader from one source group +and sends that unchanged packet through the other target groups. Its +separate L and R, all target visits, and full ordinary endpoint are +replayed too. Both words include the same complete restricted-K episode. + +For the scalar inverse transpose, each logical ADD `dst += q src` +becomes `src -= q dst` in the same chronological order. A private forward +episode collapses to a logical shear from c to y. Its separately defined +dual starts cleared at ZERO, gathers the weighted targets, ascends to FULL, +subtracts from c, and clears there. This proves the ordinary dual endpoint +`(x,y,c,d) -> (x-y,y,c,d)`. It does not apply inverse transpose to a +destructive CLEAR, and does not assert arbitrary entering private data. +Helpers may change at intermediate dual cuts. The same chronological +scalar dual is distinct from any unproved physical frame/phase lift. + +A separate closed-block matrix product checks both ordinary endpoints +without parsing the scalar event stream. The original four-port, +two-reader precursor is also rerun, including its fourteen arbitrary input +columns, incomparable-plane control, and 300/312 component bills. + +## Complete finite costs and a decision-relevant comparison + +For reduced `q=a/2^d`, the inherited cleared-work Horner price is +`p(q)=3+floor(log2(abs(a)))+popcount(abs(a))+d`, with `p(0)=0`. +Signs are absorbed into signed ADD coefficients and do not change this +price. This is a scalar lowering cost convention, not a replay of its +coefficient temporary states. Real and imaginary components cost separately. + +The mutable paths, per role, are: + +| Role | Number | Rank increments | +| --- | ---: | --- | +| Source | N | `1` repeated r-1 times, then `17-r` | +| Target | N | `r,16-r` | +| Ordinary compensation reader | N | `2`, then `1` repeated r-2 times, then `17-r` | +| Ordinary K centre | N | `17` | +| Private K episode | N | `17` | + +All ranks are paid abstract frame-transition ranks, not a fresh physical +native compiler invoice. The total is `83N`, of which `17N` is separate +private K rank. Compensation has no private episode. The complete +component scalar bills are + +``` +mutable: N(54r-1) forward, N(54r+2) dual; +static: N(72r-37) forward, N(72r-34) dual. +``` + +The same accepted complete-invoice predicate checks these formulae and +the paid cancelling-pair controls. Logical prefix L1 maxima and denominator +depths are freshly retained for each orientation. They omit Horner +temporaries and physical frame norms, so are not a whole-program precision +or approximate-child error theorem. + +There is a useful strict tradeoff. Mutable readers save +`18N(r-2)` component primitives in **each** orientation. However, compared +with static readers at the same stock and arity, their paid abstract +rank-profile pressure increases whenever `r=3,...,7` and `00`, since f is +strictly concave. Thus r2 ties and r3 through r7 are strictly worse in +this pressure measure. The complete emitted histograms are checked to +have exactly this difference. One exact rational-interval witness per r +at `m=81`, `b=.002+10^-24` supplements the all-parameter written proof. +This comparison changes the choice between these two words: scalar +savings alone do not justify the mutable schedule when the rank-profile +inequality is binding. It is not a complete physical supplier ordering. + +## The actual 4,800-module tiling + +The explicit forty disjoint acute triples partition the 120 canonical +a-root lines. Each triple has signs sigma making its pairwise inner +products +1. The b-root involution changes the second nonzero coordinate +of an integer root, or the last four coordinates of a spinor root. It +gives sixty disjoint orthogonal pairs. For every triple, b-pair and +`epsilon in {-1,+1}`, take + +``` +(a_i, epsilon sigma_i b_z), i=0,1,2; z=0,1. +``` + +The 4,800 resulting six-port sets partition exactly source IDs +`2160,...,30959`; the 2,160 pure ports are excluded. Their binary labels +are independent of epsilon. The receipt emits every one of the 2,400 +distinct label/plane/arc cases, all 4,800 signed module records, and the +complete untiled ID list. Every one of the 172,800 within-module ordered +coefficients and address parities is freshly verified. All 2,400 frame +cases pass the actual rank-two/rank-three/cap/nested-source checks. + +The module compensation is `Sigma C_3 Sigma`, where Sigma repeats the +triple sign on each pair. In the standalone complete word, conjugating +every logical register group by Sigma preserves the cost because it +changes only ADD coefficient signs. For the global compensation sum, +use `L'=L Sigma`, `R'=Sigma R`; this gives `R'L'=Sigma C_3 Sigma` +without changing the global K factor. Its signs are paid signed +coefficients, not free unrecorded physical sign gates. + +Let D be the disjoint module compensation sum. It handles exactly 115,200 +nonzero ordered entries: 57,600 each of absolute coefficients 1/16 and +5/16. The exact residual set consists of odd-Gram ordered pairs lying +outside a common six-port module. The pinned exhaustive Walsh receipt +supplies the inherited full counts; subtracting the newly checked module +counts leaves 480,222,720 entries, including 3,306,240 exceptional and +476,916,480 unit-numerator entries. That full pairing census is not +freshly enumerated here. + +## Explicit residual completion and its limitations + +There is a specified abstract completion using one old edge helper for +every residual entry. At ZERO precompensate K, module and residual dirt. +Load each edge helper while its original source still occupies its +initial line. Execute the disjoint module source gathers, reach FULL, +and run the unchanged inherited 816-centre K while all targets remain +ZERO. Deliver the modules on their rank-three final arcs and complete +the target cap climbs. Residual edge helpers then deliver at those caps, +reach FULL and undo their source gathers. Every required source line is +inside its residual target cap. The complete logical map is +`y_out = y_in + (K+D+(C-D))x = y_in+x`, with restored +ordinary logical dirt at the declared final frames. The separately +defined dual K episodes give the same-order scalar dual. + +This is a specified and counted full-domain stream, not an emitted or +executed billion-event circuit. It inherits the old full K coefficient +and support certificates. The paid paths are `[1,1,14]`, `[3,13]`, and +`[2,1,14]` on tiled sources, targets, and module readers; untiled data +retain `[16]`. Residual readers use `[1,15,1]`. All 816 ordinary K +roles and private rank 13,872 remain separate. + +Using the full K scalar bounds from the pinned K inventory, the complete +scalar component count is 11,794,300,560 forward and +11,794,303,008 dual. Against the stated all-edge completion, this saves +1,209,600 component primitives. There remain 480,251,520 ordinary +compensation roles. The complete L5 histogram includes idle work and all +helper padding; its .002 normalized moment exceeds one. Thus this +fallback does not close the desired rank-profile inequality. + +The original residual lower bounds are retained within their exact +interfaces. Since every `I-D` module block is invertible and the pure +block is identity, `rank(I-D)=30960`. The inherited 816-centre factorization gives `rank(K)<=816`, hence +`rank(C-D)>=30144`. If all residual dependence uses a private-return +interface, even ideal rank-one episodes require total private rank at +least 44,016; its coverage deficit is negative at every L. Under arbitrary +coefficient redesign confined to these disjoint modules with zero +own-group blocks, `rank(I-D)>=11760`, hence residual rank at least 10,944. +The retained exact logarithmic bound rules out the separately stipulated +favorable private-residual .002 invoice at every positive L. Neither +statement is a bound on mutable ordinary residual networks or overlapping +module constructions. + +The original optimistic whole-domain profile tables are also rerun with +all K roles, padding, idle blocks and strict child caps. Their passing +rows are conditional rank/stock screens; they do not construct a +full-domain incidence network. The exact positive-series oracle is +executed from authenticated source, but its unrelated standalone audit +main is not called. + +## Reproduction, controls and source adaptation + +Run the standard-library checker with an absolute fresh output path: + +``` +python3 check.py --output /absolute/external/path/CHECKS.json.gz +python3 -O check.py --output /absolute/external/path/CHECKS-optimized.json.gz +``` + +The source directory and origins manifest default relative to this +checker. Every input buffer is captured and authenticated before any +source execution. The full K factor and scalar bounds are inherited from +its authenticated receipt; their constants are explicitly bound, but its +large factor certificate and pricing program are not reexecuted. +Historical modules execute captured strings compiled +with `dont_inherit=True,optimize=0`; there are no runtime Git calls or +path imports of historical modules. The only executable adaptations +replace loaders/Git/provenance path access, route historical output to a +temporary directory, and add complete ordinary matrices to replay +results. No historical mathematical predicate is removed. Original and +executed-source hashes identify the adaptations. The outputs are combined +in a deterministic receipt; final output uses exclusive creation. + +Fresh controls match the intended production error type and exact guard, +rather than accepting any ValueError. They include all meaningful +historical event omissions, actual endpoint and equal-current-frame +check deletions, and cancelling paid ADD pairs that preserve the full +endpoint but fail the shared complete-invoice guard. Deleting only that +invoice guard must make the rejection oracle fail. A redundant r2 static +helper frame marker is explicitly accepted and checked to leave the full +receipt unchanged. Tiling controls duplicate an actual emitted port and +change an actual module sign, then exercise the same emitted partition +and coefficient predicates and their deletions. Coefficient failures +retain exact source/output witnesses. + +The fresh outputs are also compared by complete typed JSON projection to all +five original receipts: only the newly added ordinary-column matrices are +removed, and the rectangle's absolute provenance path is normalized to the +explicit portable path. No numerical or mathematical field is ignored. +Large original receipts use gzip transport with both raw and transport byte +hashes; their exact original bytes are recovered before comparison. The +historical notes are retained solely as provenance, not as fresh validation +of their unrelated published results. + +The original inequality-only historical diagnostics are retained as +history and rerun, but are not counted as the new defect-sensitive +controls. Normal and optimized complete receipt equality, final hashes, +and the precise package file set are recorded separately. Local replay +does not assert hosted CI, formal-kernel verification, native phases, +physical scans, ownership, coefficient-temporary precision, approximate +children, BIT composition, or an outer multiplication theorem. diff --git a/research/h6-partial-frame-networks/cyclic/VALIDATION.json b/research/h6-partial-frame-networks/cyclic/VALIDATION.json new file mode 100644 index 0000000000..b0b1df7236 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/VALIDATION.json @@ -0,0 +1,24 @@ +{ + "additional_tiling_controls": 2, + "checker_sha256": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e", + "commands": [ + "python3 check.py --output /absolute/external/CHECKS.json.gz", + "python3 -O check.py --output /absolute/external/CHECKS-optimized.json.gz" + ], + "complete_historical_receipt_projections": 5, + "cyclic_fixtures": 12, + "guards": [ + "existing output", + "relative output", + "inside package output" + ], + "normal_optimized_complete_typed_json_identical": true, + "normal_optimized_gzip_bytes_identical": true, + "precursor_fixtures": 1, + "receipt_gzip_sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4", + "receipt_raw_sha256": "f06ada7495619759967cc1160a1012d8ed12e527970fd389717c4ef9b78cc832", + "schema": "c03_cyclic_validation.v1", + "scope": "Local exact verification. No hosted CI, native phase/compiler, rounded supplier or new kappa.", + "status": "PASS", + "strict_production_controls": 289 +} diff --git a/research/h6-partial-frame-networks/cyclic/check.py b/research/h6-partial-frame-networks/cyclic/check.py new file mode 100644 index 0000000000..0133fe3cba --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/check.py @@ -0,0 +1,461 @@ +#!/usr/bin/env python3 +"""Portable exact replay of the retained C03 cyclic modules. + +Substantial OpenAI Codex assistance. Logical frame contracts only; no new kappa. +All runtime source buffers are authenticated before compilation with optimize=0. +""" +import argparse +from collections import Counter +from contextlib import redirect_stdout +import copy +from fractions import Fraction as F +import gzip +import hashlib +import io +import json +from pathlib import Path +import tempfile +import types + +ORIGINS_SHA = 'e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617' +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' + + +class CheckFailure(ValueError): + pass + + +def require(ok, guard): + if not ok: + raise CheckFailure(guard) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def replace_once(text, before, after): + require(text.count(before) == 1, 'unique source adaptation') + return text.replace(before, after, 1) + + +def authenticated_modules(source_dir, origins_path, output_dir): + manifest_raw = origins_path.read_bytes() + require(sha(manifest_raw) == ORIGINS_SHA, 'source manifest SHA256') + origins = json.loads(manifest_raw) + captured = {} + for row in origins['files']: + name = row['path'] + require(Path(name).name == name, 'flat source path') + transport = (source_dir / row.get('transport_path',name)).read_bytes() + if row.get('transport') == 'gzip': + require(len(transport)==row['transport_bytes'] and sha(transport)==row['transport_sha256'], + 'authenticated compressed source bytes: '+name) + raw=gzip.decompress(transport) + else: + raw=transport + require(len(raw) == row['bytes'] and sha(raw) == row['sha256'], + 'authenticated source bytes: ' + name) + captured[name] = raw + modules, adaptations = {}, [] + + def execute(name, source=None): + raw = captured[name] + adapted = raw.decode() if source is None else source + module = types.ModuleType('authenticated_c03_' + name.replace('.', '_')) + module.__dict__.update(__file__='/authenticated/c03/frozen/source/' + name, + _modules=modules, _captured=captured) + exec(compile(adapted, 'authenticated:' + name, 'exec', + dont_inherit=True, optimize=0), module.__dict__) + module.HERE = output_dir + modules[name] = module + adaptations.append({'file': name, 'original_sha256': sha(raw), + 'executed_source_sha256': sha(adapted.encode()), + 'changed': adapted.encode() != raw, 'optimize': 0}) + return module + + execute('invoice.py') # Only exact model/log/power functions are called. + source = captured['mixed_rectangle.py'].decode() + source = replace_once(source, + "source = Path('/Users/ross/git/math/integer-mult-bounds/research/niemeier-lattices/code/e8_cubed.py')", + "source = Path('frozen/e8_cubed.py')") + source = replace_once(source, 'hashlib.sha256(source.read_bytes()).hexdigest()', + "hashlib.sha256(_captured['e8_cubed.py']).hexdigest()") + source = replace_once(source, "'orientation':'dual' if dual else 'forward','paths':paths,", + "'orientation':'dual' if dual else 'forward','paths':paths,\n" + " 'ordinary_columns':cols,\n" + " 'ordinary_operator_rows':[[str(v) for v in rows[r]] for r in cols],") + m = execute('mixed_rectangle.py', source) + m.need = require + + source = captured['optimistic_budget.py'].decode() + begin = source.index("REPO = Path(") + end = source.index('\n\ndef dec(', begin) + source = source[:begin] + '''PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +N,H,KC,KBILL = 30960,17,816,13872 +ORACLE = 'research/h6-independent-audit/invoice/verify.py' +oracle = _modules['invoice.py'] +need = oracle.require +SOURCE_HASHES = {ORACLE:hashlib.sha256(_captured['invoice.py']).hexdigest()} +for short, rel in [('K-RESULT.json','research/h6-compensation-network/k_encoder/RESULT.json'), + ('pricing.py','research/h6-compensation-network/pricing/verify.py')]: + content = _captured[short] + SOURCE_HASHES[rel] = hashlib.sha256(content).hexdigest() + if rel.endswith('RESULT.json'): + kr = json.loads(content) + need(kr['K_ordinary_roles'] == KC and kr['private_descent_C'] == KBILL, + 'actual full K inventory') +''' + source[end:] + execute('optimistic_budget.py', source) + + source = captured['cyclic_mixed.py'].decode() + begin = source.index("spec = importlib.util.spec_from_file_location") + end = source.index('\nneed = m.need', begin) + source = source[:begin] + "m = _modules['mixed_rectangle.py']" + source[end:] + source = replace_once(source, "hashlib.sha256((HERE/'mixed_rectangle.py').read_bytes()).hexdigest()", + "hashlib.sha256(_captured['mixed_rectangle.py']).hexdigest()") + c = execute('cyclic_mixed.py', source) + + for name, following in [('dynamic_cyclic.py', "\nc = load("), + ('module_tiling.py', "\nd = load(")]: + source = captured[name].decode() + begin = source.index('\ndef load(') + end = source.index(following, begin) + source = source[:begin] + '\ndef load(name, file):\n return _modules[file]\n\n' + source[end:] + if name == 'module_tiling.py': + source = replace_once(source, + "raw = subprocess.check_output(['git','show',b.PIN+':'+path],cwd=b.REPO)", + "raw = _captured['WALSH-RESULTS.json']") + execute(name, source) + return modules, captured, adaptations + + +def expected_bill(kind, r, dual): + if kind == 'rectangle': + return 312 if dual else 300 + n = 2*r + return n*((54*r+2 if dual else 54*r-1) if kind == 'dynamic' + else (72*r-34 if dual else 72*r-37)) + + +def accept_bill(result, kind, r, dual, enabled=True): + if enabled: + require(result['scalar_primitives_before_real_doubling'] == + expected_bill(kind, r, dual), 'complete scalar invoice') + + +def expect_rejection(call, guard): + try: + call() + except CheckFailure as error: + require(str(error) == guard, 'intended rejection guard') + return {'guard': guard, 'rejected': True} + raise CheckFailure('expected rejection missing') + + +def deletion_control(module, call, guard): + original = module.need + module.need = lambda ok, label: None if label == guard else original(ok, label) + try: + try: + expect_rejection(call, guard) + except CheckFailure as error: + require(str(error) == 'expected rejection missing', 'check deletion removes detection') + return {'deleted_guard': guard, 'expected_rejection_oracle_failed': True} + raise CheckFailure('check deletion unexpectedly retained rejection') + finally: + module.need = original + + +def operator_difference(result, dual): + columns = result['ordinary_columns'] + for i, (register, row) in enumerate(zip(columns, result['ordinary_operator_rows'])): + for j, value in enumerate(row): + expected = F(i == j) + if ((not dual and register.startswith('y')) or + (dual and register.startswith('x'))): + if columns[j] == ('y' if dual else 'x') + register[1:]: + expected += -1 if dual else 1 + if F(value) != expected: + return {'output': register, 'input': columns[j], + 'actual': value, 'expected': str(expected)} + return None + + +def strengthen_controls(modules, reports): + m = modules['mixed_rectangle.py'] + controls = [] + cases = [('rectangle', None, reports['MIXED-RECTANGLE-RESULT.json']['fixtures'])] + for kind, file in [('static', 'CYCLIC-MIXED-RESULT.json'), + ('dynamic', 'DYNAMIC-CYCLIC-RESULT.json')]: + cases.extend((kind, case['r'], case['fixture']) for case in reports[file]['cases']) + frame_tags = {'source_plane', 'target_plane', 'helper_arc', 'target_arc', + 'source_read_arc', 'mutable_reader_arc', 'target_final_arc'} + for kind, r, fixture in cases: + tags = (('comp_prefix','comp_gather','comp_scatter','comp_restore','K_prefix', + 'K_gather','K_private','K_restore','source_plane','target_plane') + if kind == 'rectangle' else + ('comp_prefix','comp_gather','comp_scatter','comp_restore','K_prefix', + 'K_private','helper_arc','target_arc') if kind == 'static' else + ('mutable_read','comp_prefix','comp_scatter','comp_restore','K_private', + 'source_read_arc','mutable_reader_arc','target_final_arc')) + for tag in tags: + if kind == 'static' and r == 2 and tag == 'helper_arc': + for dual in (False, True): + baseline = m.replay(fixture, dual) + redundant = m.replay(fixture, dual, tag) + require(redundant == baseline, 'redundant rank-zero frame marker') + continue + guard = 'equal current frames' if tag in frame_tags else 'all-column exact identity with arbitrary dirt' + for dual in (False, True): + result = expect_rejection(lambda f=fixture,d=dual,t=tag: m.replay(f,d,t), guard) + controls.append(dict(kind=kind,r=r,dual=dual,omit=tag,**result)) + if kind == 'rectangle': + bad=copy.deepcopy(fixture) + event=next(e for e in bad['events'] if e['tag']=='mixed_restore_full' and e['register']=='h0') + event['frame']=fixture['planes'][1] + rejected=expect_rejection(lambda:m.replay(bad),'monotone canonical frame') + controls.append(dict(kind=kind,r=r,dual=False,mutation='unpaid_plane_reuse',**rejected)) + # Endpoint and frame check deletions exercise the actual replay predicates. + for dual in (False, True): + for tag, guard in [('comp_restore','all-column exact identity with arbitrary dirt'), + ('source_read_arc' if kind == 'dynamic' else 'source_plane', + 'equal current frames')]: + call = lambda f=fixture,d=dual,t=tag: m.replay(f,d,t) + deleted = deletion_control(m, call, guard) + if tag == 'comp_restore': + saved = m.need + m.need = lambda ok,label: None if label == guard else saved(ok,label) + try: + witness = operator_difference(call(),dual) + finally: + m.need = saved + require(witness is not None, 'actual coefficient discrepancy') + deleted['coefficient_witness'] = witness + controls.append(dict(kind=kind,r=r,dual=dual,omit=tag,**deleted)) + bad = copy.deepcopy(fixture) + first = next(e for e in bad['events'] if e['op'] == 'add') + plus = dict(first, q='1', tag='control_paid_pair') + minus = dict(first, q='-1', tag='control_paid_pair') + bad['events'][:0] = [plus, minus] + result = m.replay(bad,dual) + require(operator_difference(result,dual) is None, 'paid pair retains endpoint') + require(result['scalar_primitives_before_real_doubling'] == expected_bill(kind,r,dual)+8, + 'two paid unit Horner adds') + rejected = expect_rejection(lambda: accept_bill(result,kind,r,dual), 'complete scalar invoice') + try: + expect_rejection(lambda: accept_bill(result,kind,r,dual,False), 'complete scalar invoice') + except CheckFailure as error: + require(str(error) == 'expected rejection missing', 'invoice deletion removes detection') + else: + raise CheckFailure('invoice deletion oracle did not fail') + controls.append(dict(kind=kind,r=r,dual=dual,mutation='paid_cancelling_pair', + endpoint_accepted=True,added_component_primitives=8, + check_deletion_detected=True,**rejected)) + return controls + + +def accept_partition(ids, enabled=True): + if enabled: + require(sorted(ids) == list(range(2160,30960)), 'emitted exact partition') + + +def accept_module_coefficients(m, roots, record, enabled=True): + ports = [] + for index in record['source_ids']: + a, remainder = divmod(index-2160,240) + b, negative = divmod(remainder,2) + ports.append(roots[a]+tuple((-1 if negative else 1)*v for v in roots[b])) + witness = None + for i in range(6): + for j in range(6): + t = m.dot(ports[i],ports[j]) + actual = F(i == j)-F(t**3-4*t,48) + expected = F(0) if i//2==j//2 else F(record['signs'][i]*record['signs'][j]*(-5 if i%2==j%2 else 1),16) + if actual != expected and witness is None: + witness = {'target':i,'source':j,'gram':t,'actual':str(actual),'expected':str(expected)} + if enabled: + require(witness is None, 'emitted module coefficient identity') + return witness + + +def complete_tiling(modules): + t, m = modules['module_tiling.py'], modules['mixed_rectangle.py'] + roots, pairs, signs, _, _ = t.tiling() + packed = t.packed_root_pairs(roots) + frames, modules_out = [], [] + for ti, aa in enumerate(t.TRIPLES): + for bi, bb in enumerate(pairs): + labels = [packed[a][bj] for a in aa for bj in bb] + planes = [m.basis(labels[2*g:2*g+2]) for g in range(3)] + arcs = [m.basis(planes[g]+planes[(g+1)%3]) for g in range(3)] + frames.append({'triple_index':ti,'b_pair_index':bi,'labels':labels, + 'planes':[list(x) for x in planes], + 'final_arcs':[list(x) for x in arcs]}) + for epsilon in (-1,1): + ids = [2160+240*a+2*bj+int(epsilon*signs[ti][g]<0) + for g,a in enumerate(aa) for bj in bb] + modules_out.append({'triple_index':ti,'b_pair_index':bi,'epsilon':epsilon, + 'source_ids':ids,'signs':[s for s in signs[ti] for _ in range(2)]}) + require(len(frames)==2400 and len(modules_out)==4800, 'complete tiling emission') + ids = [i for x in modules_out for i in x['source_ids']] + accept_partition(ids) + for record in modules_out: + accept_module_coefficients(m,roots,record) + controls=[] + bad_ids=list(ids);bad_ids[0]=bad_ids[1] + bad_record=copy.deepcopy(modules_out[0]);bad_record['signs'][0]*=-1 + for name,gate,call,deleted in [ + ('duplicate_port','emitted exact partition',lambda:accept_partition(bad_ids),lambda:accept_partition(bad_ids,False)), + ('wrong_module_sign','emitted module coefficient identity',lambda:accept_module_coefficients(m,roots,bad_record),lambda:accept_module_coefficients(m,roots,bad_record,False))]: + result=expect_rejection(call,gate) + try: + expect_rejection(deleted,gate) + except CheckFailure as error: + require(str(error)=='expected rejection missing','tiling check deletion removes detection') + else: + raise CheckFailure('tiling deletion oracle did not fail') + controls.append(dict(mutation=name,check_deletion_detected=True,**result)) + controls[1]['coefficient_witness']=accept_module_coefficients(m,roots,bad_record,False) + return {'frame_cases':frames,'modules':modules_out,'production_controls':controls, + 'a_triples':[list(x) for x in t.TRIPLES],'b_pairs':[list(x) for x in pairs], + 'triple_gauge_signs':signs, + 'untiled_pure_ids':list(range(2160)), + 'sign_convention':'Each complete local logical word is conjugated by diag(sigma) on x,y,c,h; epsilon changes physical port IDs but not this conjugation.'} + + + +def compare_cyclic_words(modules, reports): + oracle=modules['invoice.py'] + records=[] + static=reports['CYCLIC-MIXED-RESULT.json']['cases'] + dynamic=reports['DYNAMIC-CYCLIC-RESULT.json']['cases'] + for old,new in zip(static,dynamic): + r,n=old['r'],old['N'] + require(r==new['r'] and n==new['N'],'matching cyclic comparison') + difference=Counter({int(k):v for k,v in new['forward']['profile'].items()}) + difference.subtract({int(k):v for k,v in old['forward']['profile'].items()}) + expected=Counter() + for rank,sign in [(17-r,1),(r,1),(15,-1),(2,-1)]: + expected[rank]+=sign*n + require(dict(+difference)==dict(+expected) and dict(-difference)==dict(-expected), + 'complete abstract rank histogram comparison') + require(sum(k*v for k,v in difference.items())==0,'equal comparison rank mass') + saving=18*n*(r-2) + for orientation in ['forward','dual']: + require(old[orientation]['scalar_primitives_before_real_doubling']- + new[orientation]['scalar_primitives_before_real_doubling']==saving, + 'exact scalar saving comparison') + lo=hi=F(0) + b=F(1,500)+F(1,10**24) + for rank,count in difference.items(): + if count: + a,z=oracle.power_interval(F(81,rank),b) + if count>0: + lo+=rank*count*(a-1);hi+=rank*count*(z-1) + else: + lo+=rank*count*(z-1);hi+=rank*count*(a-1) + require((lo==hi==0) if r==2 else lo>0,'dynamic abstract pressure tradeoff') + records.append({'r':r,'N':n,'component_primitive_saving_each_orientation':saving, + 'dynamic_minus_static_abstract_rank_histogram':{k:v for k,v in sorted(difference.items()) if v}, + 'pressure_witness_arity':81,'pressure_witness_exponent':str(b), + 'dynamic_minus_static_pressure_interval':[str(lo),str(hi)], + 'decision':'identical tariffs at r2' if r==2 else 'mutable saves scalar work but increases abstract rank pressure at the same stock'}) + return {'cases':records,'all_parameter_scope':'For0=30144. +``` + +If all residual information instead crosses a private-return interface, even +ideal rank1 episodes cost at least30144, giving total private C>=44016. The +coverage deficit is at most `-30960-13056L`, negative for every L. This is a +private-return contract result, not a bound on ordinary mixed residual readers. + +Even arbitrary coefficient redesign within these disjoint r3 blocks cannot +make that particular private-residual approach meet .002. A module correction +has zero own-group2x2 blocks, so its I-D block contains I2 and has rank at +least2. Thus globally rank(I-D)>=2*4800+2160=11760, and residual rank>=10944. +Granting free residual banks and rank1 copies, total C>=24816. Active data +alone obey pressure/(NL)>.064 log L. The global minimum over L>0 of +`.064 log L+1/L` is `.064*(1+log(125/8))`; the exact rational lower interval +exceeds `1-24816/30960` by0.0414782081167369973214388. Hence every L fails +that favorable private-residual invoice. Overlapping/composed modules and +mutable ordinary residual networks are outside this argument. + +## 2. Eight actual K centres gathered at a partial frame + +`partial_pauli.py` chooses one actual traceless diagonal Pauli group from +the retained evaluator, columns120+44i for i=0,...,7, with weight1 and +denominator8192. On doubled root-product coordinates, + +``` +q(b)=sum_j (-1)^(j&1)*b_j^2, +E_i(a,b)=a_i*q(b), K_P=E E^T/8192. +``` + +All pure-port rows of these columns vanish. Exactly24 canonical b-lines +have q!=0, with q=+-8. Their two signed copies and all120 a-lines give5760 +supported ports. Each feature has3744 nonzeros:3072 of absolute value8 and +672 of absolute value16. The actual17-bit support spans U of rank15. +Its orthogonal complement W=U-perp has rank2 and lies inside U; the support +frame is degenerate with a two-dimensional radical. All supported target caps +contain W. These complete support and inclusion statements are exhausted by +standard-library exact arithmetic and saved as literal bases in the receipt. + +Allocate the same eight ordinary dirty centres c_i already charged in the +full K word. At ZERO perform `y_t-=E_ti*c_i/8192`. Supported sources climb +from their rank1 lines to U, paying14; the centres climb ZERO->U, paying15. +At U gather `c_i+=sum_s E_si*x_s`. The sources then reach FULL, paying2. +The other808 K centres retain their full-width words, and all of their ZERO +scatters precede the target moves described next. + +There are two concrete private output interfaces: + +1. **ZERO output:** copy c_i at U, descend U->ZERO paying15, scatter + `y_t+=E_ti*private/8192`, erase the private stream. Targets then make their + normal[16] climbs. Full private K bill is13856, a saving16. +2. **Radical output:** supported targets first climb ZERO->W, paying2. Copy + c_i at U, descend U->W paying13, scatter the same coefficients, erase. + Those targets finish W->Q_t, paying14. Full private K bill is13840, + a saving32. Unsupported targets make no W visit. + +In both variants each ordinary c_i finally climbs U->FULL, paying2, and +subtracts every original gather at FULL. Sources are unchanged. The arbitrary +dirt cancellation is exactly + +``` +y -= (E/8192)d; +c = d+E^T x; +y += (E/8192)c; +c -= E^T x, +``` + +so y+=K_P x and all c are restored. The private streams are independently +cleared, copied, descended, scattered and erased. In the same-order dual, +the private stream starts at the output frame, gathers E^T y/8192, ascends +to U, subtracts from c and erases there. The endpoint is x-=K_P^T y. + +This substitutes exactly the same eight feature products in the full +factorization. It does not change the cubic kernel or invoke the odd-Gram +rank theorem. The19 actual-port diagnostic contains a rank15 support witness, +all eight feature columns and zero-feature ports. It checks every one of46 +ordinary input columns in both variants/orientations, with26 meaningful +omission/frame controls. The all-supported-input identity follows from the +displayed factor product and frame inclusions; the full5760-port matrix is +not densely replayed. + +### Complete tariffs and precision boundary + +The two variants add no ordinary centre roles or helper pads. Each selected +ordinary centre has path[15,2], instead of[17]. Supported sources have +[14,2], instead of[16]. The ZERO variant has private[15], instead of[17]. +The radical variant has private[13] and additionally supported target[2,14]. +All scalar arithmetic is unchanged: the selected group costs1258008 forward +and1258032 dual component primitives. Full K retains247217040/247219488. +Every clear, copy, weighted add and restoration is included. + +The selected subword's exact full-support logical prefix maxima are35329 +forward and152 dual, denominator depth10. Forward centre rows attain +`1+3072*8+672*16=35329`. Dual source prefixes are exhausted by the120 actual +a-roots and the nine coordinate-prefix lengths; the maximum is152. This is +a logical subword range receipt. The full composed network's coefficient +temporaries, physical frame norms and approximate-child error bounds remain +unproved. + +The private saving alone does not improve the full moment when its data +visits are newly paid. Relative to the same stock, ordinary role count and +all other unchanged costs, exact `Delta(pressure-D)/L` at m49 is: + +| Target k | ZERO output | Radical output | +|---|---:|---:| +|.002|+53.7998503674671|+107.496538804777| +|.003|+88.8945552815504|+177.634095887455| +|.005|+159.475575170436|+318.691883815945| + +Positive means worse. This sign holds for every arity: stock is unchanged, +the complete rank difference is minus the private saving, and + +``` +Delta(pressure-D)/L = m^b * sum_r DeltaH_r*r^(1-b). +``` + +The coefficient is independent of m; the exact positive interval at m49 +therefore proves the sign for all L. Both ordinary-centre and private-copy +terms are present. It is not a floor derived merely from the unsplit feature's +support span, and no general splitting/factor-network lower bound is claimed. + +The substitutions are useful if a compatible dynamic network already pays +the very same U visit, and in the second variant the same W target visit. +Under that explicit sharing premise, .003 gives negative differences +-15.8570913817969 and-31.8691974392400 per L, respectively. No compatible +global transport sharing is constructed here. Distinct Pauli support frames, +source updates and overlapping feature decompositions require fresh geometry +and accounting rather than multiplying this isolated saving. + +## Reproduction and review + +``` +python3 -I -B module_tiling.py +python3 -I -O -B module_tiling.py +python3 -I -B partial_pauli.py +python3 -I -O -B partial_pauli.py +``` + +Normal and optimized executions passed. Independent specialist review of the +Pauli words also passed in `../recursive/PARTIAL-PAULI-REVIEW.json`: a separate +actual-geometry fit,18-port arbitrary-input fixture and independent power +intervals reproduce both variants and all six moment differences. The +review binds producer SHA256 +`774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd`. +The parent separately records in `../PAULI-FIXED-SUPPORT.json` that the35 +traceless quadratic directions restrict with rank34 on the96 complementary +root lines; this fixed support cannot simply share a second independent +quadratic direction. That is a finite fixed-support statement, not a general +feature-network bound. + +The final constructive source-interface question led to the independently +reviewed theorem in `SOURCE-SMITH.md`: det(C) has odd factors, exactly560 +physical rows admit algebraic unit repair, and a560-direction stable +completion must carry changed outputs and arbitrary helper dirt. This does +not code the current native K response, whose rank816 instead requires at +least30144 repairs. A new cheap complement producer and all physical coding +costs remain missing. Final optimized receipts and independent specialist +review bindings are recorded in `HANDOFF.json`. Main/protected source +checkouts remain unchanged; no public action, commit or push occurred. diff --git a/research/h6-partial-frame-networks/cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz b/research/h6-partial-frame-networks/cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz new file mode 100644 index 0000000000..2c6786cfe0 Binary files /dev/null and b/research/h6-partial-frame-networks/cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz differ diff --git a/research/h6-partial-frame-networks/cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz b/research/h6-partial-frame-networks/cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz new file mode 100644 index 0000000000..8bf30aedff Binary files /dev/null and b/research/h6-partial-frame-networks/cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz differ diff --git a/research/h6-partial-frame-networks/cyclic/frozen/EXTENSION.md b/research/h6-partial-frame-networks/cyclic/frozen/EXTENSION.md new file mode 100644 index 0000000000..33d9841f93 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/EXTENSION.md @@ -0,0 +1,288 @@ +# Resumed area7: actual mutable readers and full paid budget + +**HANDOFF, local-only, no new kappa.** The positive result is a complete +mutable-reader circuit on six actual E8/H6 subfamilies, with arbitrary ordinary +inputs, legal nested binary frames, explicit source transport and literal +restoration. A conditional full-domain invoice passes .002 for a short-arc +profile. No full30960-port incidence network is constructed. The promising +fresh/read-only packet broadcast fails once its target visits are included. + +The scientific source remains `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +The original parent clock and deadlines are unchanged. The geometry, cubic +kernel and full816-centre K implementation are prior work, credited in +`REPORT.md`. The results here do not assert a new phase compiler, immutable tape +realization, physical bank allocation, approximate-child theorem or BIT/outer +closure. Exact common-frame identities are over dyadic scalars acting on +arbitrary complex vectors. Real and imaginary scalar work is doubled. + +## A. Complete optimistic full-domain invoice + +`optimistic_budget.py` pins the original exact rational log/exp oracle and +full K inventory through Git blobs. In every row it includes all816 ordinary +dirty K centres, their separate816 width17 private episodes, all ordinary +compensation roles, actual inherited idle blocks, child-cap splitting and all +helper padding. For odd L, + +``` +m=1+16L, q=floor(m/17), p=m-17q, +cap=floor(sqrt((m^2-1)/2)), +W=(L-1)*30960 + L*(R+816)/q, +D=(L-1)*30960 - 13872*L, +sum_r r*H_r=m*W-D. +``` + +The complete modern excess pressure is +`sum_r H_r*r*((m/r)^b-1)` with `b=k+10^-24`. Passing means pressure (x,y+(K+RL)x,c,d)=(x,y+x,c,d). +``` + +The same-order inverse-transpose word, including separately defined dual +private episodes, is `(x,y,c,d)->(x-y,y,c,d)`. The helper dirt need not remain +unchanged at intermediate dual cuts. Both endpoint identities include every +ordinary input column. A separate closed-block matrix product verifies the +same endpoints without parsing the event stream. + +All paths are literal: + +| Role | Number | Rank increments | +|---|---:|---| +| Sources |N|[1 repeated r-1 times,17-r]| +| Targets |N|[r,16-r]| +| Mutable ordinary readers |N|[2,1 repeated r-2 times,17-r]| +| Ordinary K centres |N|[17]| +| Private K episodes |N|[17]| + +The full rank mass is83N, with **zero compensation private rank**. The +cleared binary-Horner primitive bills are `N*(54r-1)` forward and +`N*(54r+2)` dual, before real/imaginary doubling. The older read-only cyclic +word costs `N*(72r-37)` and `N*(72r-34)`. At r7,N14 this changes6538/6580 +to5278/5320. It moves work from dyadic decoder scatters into unit-coefficient +source reads and keeps every restore. Logical prefix row-l1 maxima at r3 are +5/7 and at r7 are13/(61/4), forward/dual; denominator depth is4. These are +exact finite logical prefixes, excluding coefficient temporary lowering and +approximate-child error amplification. + +The finite words reject96 meaningful omissions/frame mutations. Six actual +examples are proved by exhaustive exact operator replay plus the written +frame/linear identities; no all-E8-shell network or formal kernel proof is +claimed. The abstract arc argument applies whenever the stated dimensions, +cap inclusions and nested source visits hold. The actual family currently +establishes those hypotheses only for r2,...,7. + +### What this would cost if full-domain incidence existed + +The same script prices the declared dynamic profiles with R=N on full H6, +the unchanged816-centre K, actual idle paths and padding. For short arcs r3, +source[1,1,14], target[3,13], helper[2,1,14], .002 has best L5: + +``` +m=81,q=4,p=13,W=163560,D=54480, +H={1:464400,2:154800,3:154800,13:194520, + 14:309600,16:61920,17:8160,32:123840}. +``` + +The exact normalized moment is enclosed at0.999284818183166402298971 and +the raw slack is9474.98617486556243840237. The maximum whole R for this +precise profile is53296. The actual q-replica ordinary bank count at R=N +would be158880, including4080 K centres and154800 compensation readers. +This is sufficient room to make a new full-domain construction worth testing; +it supplies no such construction or compatible owner allocation. + +Longer r7 arcs already fail .002 at R=N: Rmax30604, raw L5 slack +-200.390925084936792100027. Their source visits have consumed the short-arc +margin. At .003, r3 allows only17313 helpers at best L3, and r7 only2018; +neither permits R=N. Every profile includes all native data splits. Adding +overlapping motifs creates new source/target visits and banks; their costs +cannot be read from this single-profile table. + +The next constructive obligation is thus a full-domain incidence network +whose reader values can change along short nested arcs, with sufficiently +few separate channels and legal visits for all sources and targets, including +both1080-port pure blocks. The finite word demonstrates actual input +transport and mutable ordinary dirt; it does not justify tiling these +subfamilies while retaining the global816-centre K. + +## C. Why the fresh/read-only packet integration fails + +The coefficient identity is useful even though this integration does not +close. For canonical root a, signed b fibres write x^+=x(a,b)+x(a,-b) and +x^-=x(a,b)-x(a,-b). For fixed target a' and source b-line define + +``` +F0=sum_(a dot a' even) w(a)*x^-(a,b), w=1 except w(a')=-3, +F1=sum_(a dot a' odd) (a dot a')*x^+(a,b), +F2=sum_(a dot a' odd) x^-(a,b), P=x^+(a',b). +``` + +For target b'=sigma times a canonical b-line, v=b dot b', its contribution is +`sigma*v*F0/16-P/8` when v is odd, `F1/16` when v=0, and +`-3F1/16-sigma*F2/8` on the same b-line. All64 scalar cases, diagonal I +and exceptional E included, are checked in `partial_filter.py`. + +The promising inventory was14400 line-loaded rank8 readers[1,7,8,1],28800 +fresh rank8 packets[8,8,1], and14400 plus-input P readers[1,15,1]. With +coarse data[16] this57600-role relaxation has positive raw .002,L5 slack +583.999206892367372813360. It omits delivery chronology and pure-block work. + +Its read-only F1 broadcasts cannot retain those coarse target paths. For +fixed a', each F1(a',b) serves64 distinct target b-line caps: those orthogonal +or equal to b. With R_E8=(a_i dot a_j)^2 on the120 canonical root-lines, +their incidence matrix O is `J-R_E8+4I`. Exact root association gives + +``` +R_E8^2=12R_E8+24J, O^2=32J+4R_E8+16I. +``` + +Any two distinct target caps therefore share32 or36 F1 packets. A single +ordinary packet on a monotone path can scatter at at most one full rank16 +cap. Thus two different caps cannot both have unsplit[16] target paths: +their shared read-only packet would have to visit two incomparable caps. +At most one cap per a' remains unsplit, forcing120*119*2=28560 root-product +targets to have a proper intermediate visit. Even the cheapest favorable +proper split[15,1] changes the exact L5 slack to +**-490.030752304113480001040**. No transport or pure-block surcharge is +needed for that sign change. Odd L3,...,79 fail directly; active/helper mass +gives a positive logarithmic failure tail for L≥81. The retained relaxation +passing and the paid chronology failing are negative controls against a +dimension-only invoice. `packet_broadcast.py` contains all7140 common-packet +witnesses and exact complete invoices. + +This applies to the stated one-packet-per-F1 read-only direct-broadcast +architecture. Mutable packets, helper-to-helper routing, changed roles, +changed factorization, interleaving and changed K are outside the proof. +It is not a lower bound on arbitrary dynamic compensation circuits. + +Two earlier bounded integration attempts remain in the receipts. The literal +minimal-prefix Witt bank has210 source frames per outer b-line; each actual +weighted Gram block has rank4, yielding100800 channels even before other +coefficient terms. Its most favorable declared invoice fails .002. The G/V +compression gathers into rank9, while its desired F packets have rank8; +paying one private rank per(a',b) already fails. That premise does not exclude +direct rank8 computation. These are scoped failures of particular +factorizations, not a universal helper lower bound. The connected support +and group-partition certificates likewise do not prohibit dynamic networks. + +## D. Odd-Gram novelty and independent review boundary + +The new candidate theorem is the six-sector two-parameter classification in +`REPORT.md` section3, with exact noncubic minimum root ranks9424 and20400. +The underlying cubic sector method, root Hadamard ranks8/36/120, canonical +120x240 correction and full K816 spectrum are already in PR606/PR1830; +they are credited as inputs. The result should not be described as a new +discovery of that spectrum or as a lower bound on partial-frame centres. + +At2026-10-18 12:28UTC, read-only GitHub connector searches found no PR results +for H6 quintic, H6 polynomial rank, H6 odd Gram, quintic or septic. The query +odd polynomial found only unrelated PR977; H6 in:title found PR1830 and1698. +Current main's spectral README blob +`e7b1d7354b26c3c5d09c71a141c41414d0ec5545` matches the pinned input. +`NOVELTY-RESUME.json` preserves exact search coverage. These bounded queries +and read main packages found no matching classification; they do not establish +absolute novelty, exhaust live Discussions or cover unpublished work. + +The theorem is suitable for independent standalone review: a standard-library +deterministic script, all57600 root quadratic-association coefficients, +exact rational projector identities,18 actual28800-column sector actions, +complete affine zero-line reasoning and four defect controls. The written +projector proof supplies the all-parameter rank argument; finite parameter +tests alone do not. It has not yet received external independent review or +formal kernel verification. Publication is the parent's separate decision. + +## Reproduction and remaining obligations + +From this owned directory, every command below writes only its local receipt: + +``` +python3 -I -O -B odd_gram_rank.py +python3 -I -O -B mixed_rectangle.py +python3 -I -O -B independent_blocks.py +python3 -I -O -B cyclic_mixed.py +python3 -I -O -B optimistic_budget.py +python3 -I -O -B partial_filter.py +python3 -I -O -B partition_screen.py +python3 -I -O -B packet_broadcast.py +python3 -I -O -B dynamic_cyclic.py +``` + +Normal executions passed each new result. Optimized executions and final byte +hashes are recorded in `HANDOFF.json`. No primary/protected checkout mutation, +public claim, commit, push or publication was made. The open obligations are +the full30960-port dynamic network and source/target chronology; literal +phase/adapters; physical banks, ownership and controller/tape; coefficient +temporary and approximate-child precision; and a compatible complete BIT +supplier plus outer analytic transfer. Passing a favorable invoice settles +none of those implementation or theorem interfaces. diff --git a/research/h6-partial-frame-networks/cyclic/frozen/K-RESULT.json b/research/h6-partial-frame-networks/cyclic/frozen/K-RESULT.json new file mode 100644 index 0000000000..31368ec6d6 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/K-RESULT.json @@ -0,0 +1,196 @@ +{ + "K_dual_primitive_bound": 247219488, + "K_forward_primitive_bound": 247217040, + "K_full_scalar_additions": 25760832, + "K_ordinary_roles": 816, + "N": 30960, + "diagonal_denominator": 8192, + "factor_centers": 816, + "factor_evaluator_diagnostic_rows": [ + 0, + 101, + 202, + 303, + 404, + 505, + 606, + 707, + 808, + 909, + 1010, + 1111, + 1212, + 1313, + 1414, + 1515, + 1616, + 1717, + 1818, + 1919, + 2020, + 2121, + 2160, + 3137, + 4114, + 5091, + 6068, + 7045, + 8022, + 8999, + 9976, + 10953, + 11930, + 12907, + 13884, + 14861, + 15838, + 16815, + 17792, + 18769, + 19746, + 20723, + 21700, + 22677, + 23654, + 24631, + 25608, + 26585, + 27562, + 28539, + 29516, + 30493 + ], + "feature_nonzeros": 6440208, + "fixtures": [ + { + "all_basis_columns": 844, + "artifact": "fixture-8-forward.json.gz", + "center_path": [ + 17 + ], + "dual": false, + "event_count": 5604, + "ordinary_center_roles": 816, + "private_episodes": 816, + "private_rank_mass": 13872, + "status": "PASS_ALL_COLUMNS_IDENTITY_SHEAR", + "uncompressed_sha256": "41211416c933a6ad5e281f4c56dc43809ef948a7da4ad55f97b09a499bae4b18" + }, + { + "all_basis_columns": 844, + "artifact": "fixture-8-dual.json.gz", + "center_path": [ + 17 + ], + "dual": true, + "event_count": 5604, + "ordinary_center_roles": 816, + "private_episodes": 816, + "private_rank_mass": 13872, + "status": "PASS_ALL_COLUMNS_IDENTITY_SHEAR", + "uncompressed_sha256": "d195711101db4f2fb921d05ffbb8f7e9eb97ce0db0aca53484772cb62532dcd4" + }, + { + "all_basis_columns": 1288, + "artifact": "fixture-32-forward.json.gz", + "center_path": [ + 17 + ], + "dual": false, + "event_count": 18544, + "ordinary_center_roles": 816, + "private_episodes": 816, + "private_rank_mass": 13872, + "status": "PASS_ALL_COLUMNS_IDENTITY_SHEAR", + "uncompressed_sha256": "25b8ffcbfba50f43d41bdb5b024fd9b20f8d56f0b83eea02870cd2163721f7cf" + }, + { + "all_basis_columns": 1288, + "artifact": "fixture-32-dual.json.gz", + "center_path": [ + 17 + ], + "dual": true, + "event_count": 18544, + "ordinary_center_roles": 816, + "private_episodes": 816, + "private_rank_mass": 13872, + "status": "PASS_ALL_COLUMNS_IDENTITY_SHEAR", + "uncompressed_sha256": "c25b95ae03b95f1d364b1deb5060750cbc4eef56b713463da5a32cf2cce807d6" + } + ], + "full_composed_event_count": 3388192272, + "full_composed_event_count_status": "symbolic exhaustive-incidence count; full stream not materialized", + "full_composed_event_iterator": "event_records(P,packed,range(30960),W,dual=False_or_True)", + "full_factor_certificate": { + "A_int64_sha256": "6a364e4067fecd8fbf9014257c158ddfe19b3957561bafc189a947180a97c362", + "checked_entries": 665856, + "identity": "A^T diag(w) A =384D-96UU^T; features=A*monomials/12, K=E diag(w) E^T/8192 on sum u_i^2=16", + "monomials": 816, + "status": "PASS_ALL_665856_EXACT_COEFFICIENTS", + "weights_sha256": "963cdca8209d1a529cb722a0712742b6011dfed0e1297d03c52d5462c542acf6" + }, + "gather_coefficients": { + "-1": 1012672, + "-16": 208664, + "-2": 933184, + "-3": 10752, + "-5": 448, + "-6": 9408, + "-8": 1118256, + "1": 996416, + "16": 222328, + "2": 822976, + "3": 10752, + "5": 576, + "6": 12096, + "8": 1081680 + }, + "h": 17, + "max_abs_gather_coefficient": "16", + "max_abs_scatter_coefficient": "1/16", + "negative_controls": { + "False:K_FULL_undo_gather": "REJECTED", + "False:K_dirt_prefix": "REJECTED", + "False:K_gather": "REJECTED", + "False:K_private_erase": "REJECTED", + "False:K_scatter": "REJECTED", + "True:K_FULL_undo_gather": "REJECTED", + "True:K_dirt_prefix": "REJECTED", + "True:K_gather": "REJECTED", + "True:K_private_erase": "REJECTED", + "True:K_scatter": "REJECTED" + }, + "ordinary_center_path": [ + 17 + ], + "primitive_convention": "3+(bits(numerator)-1)+popcount(numerator)+(bits(denominator)-1) per weighted addition; clear/copy1 each, dual copy replacement unit add4", + "private_descent_C": 13872, + "private_full_to_zero_copies": 816, + "scatter_coefficients": { + "-1/1024": 1793344, + "-1/128": 344, + "-1/256": 275248, + "-1/512": 1066240, + "-1/64": 2240, + "-3/1024": 139968, + "-3/512": 44352, + "-5/256": 448, + "1/1024": 1683136, + "1/128": 552, + "1/16": 16, + "1/256": 207056, + "1/512": 1066240, + "1/64": 2240, + "3/1024": 127296, + "3/512": 30912, + "5/256": 576 + }, + "scope": "Explicit finite local scalar/frame/copy construction; no K_interface macro. Complete all-pair polynomial factor identity, bounded all-basis chronological lifecycle replays, fully charged local center descent. Physical endpoint representatives, adapter compiler, precision and all-size supplier admission remain external gates.", + "source_sha256": { + "research/h6-compensation-network/construction/network.py": "e1bd9e43179835d16f9ec561ecd61585cf320a71550da49646f5d62da744b4f1", + "research/niemeier-lattices/code/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "research/niemeier-lattices/code/e8_sections.py": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + "status": "PASS_EXPLICIT_K_WORD_AND_COMPOSED_FIXTURES" +} diff --git a/research/h6-partial-frame-networks/cyclic/frozen/MIXED-RECTANGLE-RESULT.json b/research/h6-partial-frame-networks/cyclic/frozen/MIXED-RECTANGLE-RESULT.json new file mode 100644 index 0000000000..e7960fec06 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/MIXED-RECTANGLE-RESULT.json @@ -0,0 +1,1424 @@ +{ + "actual_geometry_sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "actual_geometry_source": "/Users/ross/git/math/integer-mult-bounds/research/niemeier-lattices/code/e8_cubed.py", + "canonical_head": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "cost_limitation": "Four full-width K centers have private rank68, so this four-port finite supplier has negative all-stage coverage even before compensation. The full30960-port H6 K factor has816 centers and C13872; no composition of these rectangles or full-domain loading/chronology is constructed.", + "edge_baseline_helpers": 8, + "fixtures": { + "K": [ + [ + "1", + "0", + "-1/16", + "-1/16" + ], + [ + "0", + "1", + "-1/16", + "-1/16" + ], + [ + "-1/16", + "-1/16", + "1", + "0" + ], + [ + "-1/16", + "-1/16", + "0", + "1" + ] + ], + "ends": { + "c0": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "c1": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "c2": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "c3": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "h0": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "h1": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "x0": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "x1": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "x2": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "x3": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "y0": [ + 65538, + 32768, + 16386, + 8194, + 4096, + 2048, + 1026, + 514, + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "y1": [ + 65536, + 32768, + 16385, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 129, + 64, + 32, + 17, + 9, + 4, + 2 + ], + "y2": [ + 65538, + 32770, + 16386, + 8192, + 4098, + 2048, + 1024, + 512, + 256, + 130, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "y3": [ + 65536, + 32769, + 16385, + 8193, + 4097, + 2048, + 1025, + 513, + 256, + 128, + 64, + 32, + 17, + 9, + 4, + 2 + ] + }, + "events": [ + { + "dst": "y0", + "op": "add", + "q": "-1/16", + "src": "h1", + "tag": "comp_prefix" + }, + { + "dst": "y0", + "op": "add", + "q": "-1", + "src": "c0", + "tag": "K_prefix" + }, + { + "dst": "y0", + "op": "add", + "q": "1/16", + "src": "c2", + "tag": "K_prefix" + }, + { + "dst": "y0", + "op": "add", + "q": "1/16", + "src": "c3", + "tag": "K_prefix" + }, + { + "dst": "y1", + "op": "add", + "q": "-1/16", + "src": "h1", + "tag": "comp_prefix" + }, + { + "dst": "y1", + "op": "add", + "q": "-1", + "src": "c1", + "tag": "K_prefix" + }, + { + "dst": "y1", + "op": "add", + "q": "1/16", + "src": "c2", + "tag": "K_prefix" + }, + { + "dst": "y1", + "op": "add", + "q": "1/16", + "src": "c3", + "tag": "K_prefix" + }, + { + "dst": "y2", + "op": "add", + "q": "-1/16", + "src": "h0", + "tag": "comp_prefix" + }, + { + "dst": "y2", + "op": "add", + "q": "1/16", + "src": "c0", + "tag": "K_prefix" + }, + { + "dst": "y2", + "op": "add", + "q": "1/16", + "src": "c1", + "tag": "K_prefix" + }, + { + "dst": "y2", + "op": "add", + "q": "-1", + "src": "c2", + "tag": "K_prefix" + }, + { + "dst": "y3", + "op": "add", + "q": "-1/16", + "src": "h0", + "tag": "comp_prefix" + }, + { + "dst": "y3", + "op": "add", + "q": "1/16", + "src": "c0", + "tag": "K_prefix" + }, + { + "dst": "y3", + "op": "add", + "q": "1/16", + "src": "c1", + "tag": "K_prefix" + }, + { + "dst": "y3", + "op": "add", + "q": "-1", + "src": "c3", + "tag": "K_prefix" + }, + { + "frame": [ + 75519, + 16537 + ], + "op": "climb", + "register": "x0", + "tag": "source_plane" + }, + { + "frame": [ + 75519, + 16537 + ], + "op": "climb", + "register": "x1", + "tag": "source_plane" + }, + { + "frame": [ + 75519, + 16537 + ], + "op": "climb", + "register": "h0", + "tag": "mixed_gather_plane" + }, + { + "dst": "h0", + "op": "add", + "q": "1", + "src": "x0", + "tag": "comp_gather" + }, + { + "dst": "h0", + "op": "add", + "q": "1", + "src": "x1", + "tag": "comp_gather" + }, + { + "frame": [ + 75519, + 63001 + ], + "op": "climb", + "register": "x2", + "tag": "source_plane" + }, + { + "frame": [ + 75519, + 63001 + ], + "op": "climb", + "register": "x3", + "tag": "source_plane" + }, + { + "frame": [ + 75519, + 63001 + ], + "op": "climb", + "register": "h1", + "tag": "mixed_gather_plane" + }, + { + "dst": "h1", + "op": "add", + "q": "1", + "src": "x2", + "tag": "comp_gather" + }, + { + "dst": "h1", + "op": "add", + "q": "1", + "src": "x3", + "tag": "comp_gather" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "x0", + "tag": "source_full" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "x1", + "tag": "source_full" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "x2", + "tag": "source_full" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "x3", + "tag": "source_full" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "c0", + "tag": "K_center_full" + }, + { + "dst": "c0", + "op": "add", + "q": "1", + "src": "x0", + "tag": "K_gather" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "c1", + "tag": "K_center_full" + }, + { + "dst": "c1", + "op": "add", + "q": "1", + "src": "x1", + "tag": "K_gather" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "c2", + "tag": "K_center_full" + }, + { + "dst": "c2", + "op": "add", + "q": "1", + "src": "x2", + "tag": "K_gather" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "c3", + "tag": "K_center_full" + }, + { + "dst": "c3", + "op": "add", + "q": "1", + "src": "x3", + "tag": "K_gather" + }, + { + "center": "c0", + "op": "private", + "tag": "K_private", + "targets": [ + [ + "y0", + "1" + ], + [ + "y2", + "-1/16" + ], + [ + "y3", + "-1/16" + ] + ] + }, + { + "center": "c1", + "op": "private", + "tag": "K_private", + "targets": [ + [ + "y1", + "1" + ], + [ + "y2", + "-1/16" + ], + [ + "y3", + "-1/16" + ] + ] + }, + { + "center": "c2", + "op": "private", + "tag": "K_private", + "targets": [ + [ + "y0", + "-1/16" + ], + [ + "y1", + "-1/16" + ], + [ + "y2", + "1" + ] + ] + }, + { + "center": "c3", + "op": "private", + "tag": "K_private", + "targets": [ + [ + "y0", + "-1/16" + ], + [ + "y1", + "-1/16" + ], + [ + "y3", + "1" + ] + ] + }, + { + "dst": "c0", + "op": "add", + "q": "-1", + "src": "x0", + "tag": "K_restore" + }, + { + "dst": "c1", + "op": "add", + "q": "-1", + "src": "x1", + "tag": "K_restore" + }, + { + "dst": "c2", + "op": "add", + "q": "-1", + "src": "x2", + "tag": "K_restore" + }, + { + "dst": "c3", + "op": "add", + "q": "-1", + "src": "x3", + "tag": "K_restore" + }, + { + "frame": [ + 75519, + 63001 + ], + "op": "climb", + "register": "y0", + "tag": "target_plane" + }, + { + "frame": [ + 75519, + 63001 + ], + "op": "climb", + "register": "y1", + "tag": "target_plane" + }, + { + "frame": [ + 75519, + 16537 + ], + "op": "climb", + "register": "y2", + "tag": "target_plane" + }, + { + "frame": [ + 75519, + 16537 + ], + "op": "climb", + "register": "y3", + "tag": "target_plane" + }, + { + "dst": "y0", + "op": "add", + "q": "1/16", + "src": "h1", + "tag": "comp_scatter" + }, + { + "dst": "y1", + "op": "add", + "q": "1/16", + "src": "h1", + "tag": "comp_scatter" + }, + { + "dst": "y2", + "op": "add", + "q": "1/16", + "src": "h0", + "tag": "comp_scatter" + }, + { + "dst": "y3", + "op": "add", + "q": "1/16", + "src": "h0", + "tag": "comp_scatter" + }, + { + "frame": [ + 65538, + 32768, + 16386, + 8194, + 4096, + 2048, + 1026, + 514, + 256, + 128, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "op": "climb", + "register": "y0", + "tag": "target_cap" + }, + { + "frame": [ + 65536, + 32768, + 16385, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 129, + 64, + 32, + 17, + 9, + 4, + 2 + ], + "op": "climb", + "register": "y1", + "tag": "target_cap" + }, + { + "frame": [ + 65538, + 32770, + 16386, + 8192, + 4098, + 2048, + 1024, + 512, + 256, + 130, + 66, + 34, + 16, + 8, + 6, + 1 + ], + "op": "climb", + "register": "y2", + "tag": "target_cap" + }, + { + "frame": [ + 65536, + 32769, + 16385, + 8193, + 4097, + 2048, + 1025, + 513, + 256, + 128, + 64, + 32, + 17, + 9, + 4, + 2 + ], + "op": "climb", + "register": "y3", + "tag": "target_cap" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "h0", + "tag": "mixed_restore_full" + }, + { + "dst": "h0", + "op": "add", + "q": "-1", + "src": "x0", + "tag": "comp_restore" + }, + { + "dst": "h0", + "op": "add", + "q": "-1", + "src": "x1", + "tag": "comp_restore" + }, + { + "frame": [ + 65536, + 32768, + 16384, + 8192, + 4096, + 2048, + 1024, + 512, + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "op": "climb", + "register": "h1", + "tag": "mixed_restore_full" + }, + { + "dst": "h1", + "op": "add", + "q": "-1", + "src": "x2", + "tag": "comp_restore" + }, + { + "dst": "h1", + "op": "add", + "q": "-1", + "src": "x3", + "tag": "comp_restore" + } + ], + "labels": [ + 91750, + 16537, + 119014, + 63001 + ], + "planes": [ + [ + 75519, + 16537 + ], + [ + 75519, + 63001 + ] + ], + "ports_doubled": [ + [ + 2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0, + 0 + ], + [ + 2, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2 + ] + ], + "source_indices": [ + 27812, + 27640, + 27852, + 27840 + ], + "starts": { + "c0": [], + "c1": [], + "c2": [], + "c3": [], + "h0": [], + "h1": [], + "x0": [ + 91750 + ], + "x1": [ + 16537 + ], + "x2": [ + 119014 + ], + "x3": [ + 63001 + ], + "y0": [], + "y1": [], + "y2": [], + "y3": [] + } + }, + "ordinary_comp_helpers": 2, + "orientations": [ + { + "logical_prefix_denominator_depth": 4, + "logical_prefix_row_l1": "3", + "orientation": "forward", + "paths": { + "c0": [ + 17 + ], + "c1": [ + 17 + ], + "c2": [ + 17 + ], + "c3": [ + 17 + ], + "h0": [ + 2, + 15 + ], + "h1": [ + 2, + 15 + ], + "x0": [ + 1, + 15 + ], + "x1": [ + 1, + 15 + ], + "x2": [ + 1, + 15 + ], + "x3": [ + 1, + 15 + ], + "y0": [ + 2, + 14 + ], + "y1": [ + 2, + 14 + ], + "y2": [ + 2, + 14 + ], + "y3": [ + 2, + 14 + ] + }, + "private_episodes": 4, + "private_rank": 68, + "profile": { + "1": 4, + "2": 6, + "14": 4, + "15": 6, + "17": 8 + }, + "rank_mass": 298, + "scalar_adds": 48, + "scalar_primitives_before_real_doubling": 300 + }, + { + "logical_prefix_denominator_depth": 4, + "logical_prefix_row_l1": "4", + "orientation": "dual", + "paths": { + "c0": [ + 17 + ], + "c1": [ + 17 + ], + "c2": [ + 17 + ], + "c3": [ + 17 + ], + "h0": [ + 2, + 15 + ], + "h1": [ + 2, + 15 + ], + "x0": [ + 1, + 15 + ], + "x1": [ + 1, + 15 + ], + "x2": [ + 1, + 15 + ], + "x3": [ + 1, + 15 + ], + "y0": [ + 2, + 14 + ], + "y1": [ + 2, + 14 + ], + "y2": [ + 2, + 14 + ], + "y3": [ + 2, + 14 + ] + }, + "private_episodes": 4, + "private_rank": 68, + "profile": { + "1": 4, + "2": 6, + "14": 4, + "15": 6, + "17": 8 + }, + "rank_mass": 298, + "scalar_adds": 52, + "scalar_primitives_before_real_doubling": 312 + } + ], + "rejected_controls": [ + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_prefix" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_prefix" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_gather" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_gather" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_scatter" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_scatter" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_restore" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "comp_restore" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_prefix" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_prefix" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_gather" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_gather" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_private" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_private" + }, + { + "dual": false, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_restore" + }, + { + "dual": true, + "gate": "all-column exact identity with arbitrary dirt", + "omit": "K_restore" + }, + { + "dual": false, + "gate": "equal current frames", + "omit": "source_plane" + }, + { + "dual": true, + "gate": "equal current frames", + "omit": "source_plane" + }, + { + "dual": false, + "gate": "equal current frames", + "omit": "target_plane" + }, + { + "dual": true, + "gate": "equal current frames", + "omit": "target_plane" + }, + { + "gate": "monotone canonical frame", + "mutant": "unpaid_plane_reuse" + } + ], + "remaining": "Frame Clifford phases/adapters, coefficient temporary streams, approximate-child precision, actual banks/controller/tape and full-domain composition are not independently verified.", + "status": "PASS_ACTUAL_H6_MIXED_RECTANGLE_ALL_INPUT_WORD_NO_NEW_KAPPA" +} diff --git a/research/h6-partial-frame-networks/cyclic/frozen/MODULE-TILING-RESULT.json b/research/h6-partial-frame-networks/cyclic/frozen/MODULE-TILING-RESULT.json new file mode 100644 index 0000000000..b5bb691f2c --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/MODULE-TILING-RESULT.json @@ -0,0 +1,2028 @@ +{ + "a_triples": [ + [ + 0, + 62, + 66 + ], + [ + 1, + 17, + 92 + ], + [ + 2, + 10, + 76 + ], + [ + 3, + 56, + 68 + ], + [ + 4, + 36, + 50 + ], + [ + 5, + 42, + 101 + ], + [ + 6, + 12, + 109 + ], + [ + 7, + 88, + 96 + ], + [ + 8, + 89, + 112 + ], + [ + 9, + 78, + 116 + ], + [ + 11, + 51, + 99 + ], + [ + 13, + 108, + 115 + ], + [ + 14, + 29, + 31 + ], + [ + 15, + 83, + 103 + ], + [ + 16, + 71, + 117 + ], + [ + 18, + 52, + 91 + ], + [ + 19, + 32, + 73 + ], + [ + 20, + 41, + 107 + ], + [ + 21, + 49, + 55 + ], + [ + 22, + 38, + 67 + ], + [ + 23, + 27, + 28 + ], + [ + 24, + 87, + 113 + ], + [ + 25, + 26, + 65 + ], + [ + 30, + 35, + 106 + ], + [ + 33, + 45, + 94 + ], + [ + 34, + 98, + 119 + ], + [ + 37, + 48, + 72 + ], + [ + 39, + 59, + 69 + ], + [ + 40, + 63, + 85 + ], + [ + 43, + 77, + 114 + ], + [ + 44, + 60, + 64 + ], + [ + 46, + 54, + 93 + ], + [ + 47, + 79, + 81 + ], + [ + 53, + 90, + 102 + ], + [ + 57, + 74, + 105 + ], + [ + 58, + 70, + 111 + ], + [ + 61, + 97, + 118 + ], + [ + 75, + 95, + 110 + ], + [ + 80, + 86, + 104 + ], + [ + 82, + 84, + 100 + ] + ], + "actual_full_completion": { + "K_private_C": 13872, + "L5_complete_histogram": { + "1": "4802659200", + "2": "144000", + "3": "144000", + "13": "600459420", + "14": "288000", + "15": "2401113600", + "16": "83520", + "17": "8160", + "32": "123840" + }, + "L5_q_replica_banks": 2401261680, + "L5_stock_W": "600439260", + "L5_target_002": { + "exponent_b": "2000000000000000000001/1000000000000000000000000", + "normalized_moment": { + "hi": "1.00396149237658136716079", + "lo": "1.00396149237658136716079", + "lower": "203451039748492928131887419340948681270512088788981841779991411062483/202648250250000000000000000000000000000000000000000000000000000000000", + "upper": "10850722119919622833700662364850596334427311402079031561599552731227/10807906680000000000000000000000000000000000000000000000000000000000" + }, + "pressure": { + "hi": "192723959.638302751652981", + "lo": "192723959.638302751652981", + "lower": "2409049495478784395662258022846043811536266366945525339974233187449/12500000000000000000000000000000000000000000000000000000000", + "upper": "385447919276605503305961283655367009845802618711284054395974581043/2000000000000000000000000000000000000000000000000000000000" + }, + "raw_slack": { + "hi": "-192669479.638302751652981", + "lo": "-192669479.638302751652981", + "lower": "-385338959276605503305961283655367009845802618711284054395974581043/2000000000000000000000000000000000000000000000000000000000", + "upper": "-2408368495478784395662258022846043811536266366945525339974233187449/12500000000000000000000000000000000000000000000000000000000" + }, + "target": "1/500", + "verdict": "FAILS_OPTIMISTIC_RANK_SCREEN" + }, + "component_primitives_dual": 11794303008, + "component_primitives_forward": 11794300560, + "component_saving_against_full_edge_word": 1209600, + "module_readers": 28800, + "ordinary_K_centres": 816, + "residual_edge_readers": 480222720, + "total_ordinary_compensation_roles": 480251520, + "word_contract": "AtZERO precompensate K,module and residual dirt. Load every residual edge helper at its original source line before module source climbs. Execute changing module gathers on disjoint nested arcs; sources reachFULL. Run unchanged816-centre K while targetsZERO. Deliver modules at their rank3 arcs, then targets finish caps. Deliver each residual edge helper at its rank16 target cap. Restore all compensation helpers atFULL. Same-order dual has separate K private episodes. Full billion-event stream is mathematically specified/counted, not materialized." + }, + "actual_module_frame_cases": 2400, + "actual_private_residual": { + "all_L_coverage_deficit_upper": "-30960-13056*L", + "best_private_rank_floor": 30144, + "rank_I_minus_D": 30960, + "rank_lower": 30144, + "total_private_C_lower": 44016 + }, + "actual_tiled_ports": 28800, + "b_orthogonal_involution_pairs": [ + [ + 0, + 1 + ], + [ + 2, + 5 + ], + [ + 3, + 4 + ], + [ + 6, + 11 + ], + [ + 7, + 10 + ], + [ + 8, + 9 + ], + [ + 12, + 19 + ], + [ + 13, + 18 + ], + [ + 14, + 17 + ], + [ + 15, + 16 + ], + [ + 20, + 29 + ], + [ + 21, + 28 + ], + [ + 22, + 27 + ], + [ + 23, + 26 + ], + [ + 24, + 25 + ], + [ + 30, + 41 + ], + [ + 31, + 40 + ], + [ + 32, + 39 + ], + [ + 33, + 38 + ], + [ + 34, + 37 + ], + [ + 35, + 36 + ], + [ + 42, + 49 + ], + [ + 43, + 48 + ], + [ + 44, + 47 + ], + [ + 45, + 46 + ], + [ + 50, + 57 + ], + [ + 51, + 56 + ], + [ + 52, + 55 + ], + [ + 53, + 54 + ], + [ + 58, + 65 + ], + [ + 59, + 64 + ], + [ + 60, + 63 + ], + [ + 61, + 62 + ], + [ + 66, + 73 + ], + [ + 67, + 72 + ], + [ + 68, + 71 + ], + [ + 69, + 70 + ], + [ + 74, + 81 + ], + [ + 75, + 80 + ], + [ + 76, + 79 + ], + [ + 77, + 78 + ], + [ + 82, + 89 + ], + [ + 83, + 88 + ], + [ + 84, + 87 + ], + [ + 85, + 86 + ], + [ + 90, + 97 + ], + [ + 91, + 96 + ], + [ + 92, + 95 + ], + [ + 93, + 94 + ], + [ + 98, + 105 + ], + [ + 99, + 104 + ], + [ + 100, + 103 + ], + [ + 101, + 102 + ], + [ + 106, + 119 + ], + [ + 107, + 118 + ], + [ + 108, + 117 + ], + [ + 109, + 116 + ], + [ + 110, + 115 + ], + [ + 111, + 114 + ], + [ + 112, + 113 + ] + ], + "canonical_roots": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + -2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + -2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + -2, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 1 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + -1, + 1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 1, + -1, + -1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + -1, + -1, + 1, + 1 + ], + [ + 1, + -1, + -1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + -1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1 + ], + [ + 1, + -1, + -1, + 1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + -1, + 1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + -1, + -1, + 1, + 1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + 1, + -1, + -1 + ], + [ + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + -1, + -1 + ], + [ + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + 1, + -1, + 1 + ], + [ + 1, + -1, + 1, + 1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + -1, + 1 + ], + [ + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + -1, + 1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + -1, + -1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + -1, + -1 + ], + [ + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + -1, + 1, + 1, + -1, + 1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1 + ], + [ + 1, + 1, + -1, + 1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1 + ], + [ + 1, + 1, + 1, + -1, + -1, + -1, + 1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + 1, + -1, + -1 + ], + [ + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + 1, + -1, + 1 + ], + [ + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1 + ], + [ + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1 + ], + [ + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1 + ], + [ + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 2, + -2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + -2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + -2, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + -2, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + -2, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + -2 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "controls": { + "b_mates_are_distinct": true, + "dropping_residual_changes_operator": true, + "pure_ports_not_claimed_tiled": true, + "tile_signs_required": true + }, + "covered_exceptional_entries": 57600, + "covered_ordered_nonzero_entries": 115200, + "covered_unit_entries": 57600, + "exact_uncovered_set": "All ordered pairs(t,s) with actual odd Gram t_ts and with t,s not belonging to the same six-port module above. Every pair involving a pure port is outside the modules; within-module C equals D exactly.", + "frame_examples": [ + { + "b_pair": 0, + "final_arcs": [ + [ + 65749, + 62473, + 554 + ], + [ + 66207, + 63011, + 96 + ], + [ + 65717, + 62473, + 586 + ] + ], + "labels": [ + 128758, + 62473, + 63011, + 128220, + 63043, + 128188 + ], + "planes": [ + [ + 66303, + 62473 + ], + [ + 66303, + 63011 + ], + [ + 66303, + 63043 + ] + ], + "triple": 0 + }, + { + "b_pair": 1, + "final_arcs": [ + [ + 65749, + 58633, + 554 + ], + [ + 66207, + 59171, + 96 + ], + [ + 65717, + 58633, + 586 + ] + ], + "labels": [ + 124918, + 58633, + 59171, + 124380, + 59203, + 124348 + ], + "planes": [ + [ + 66303, + 58633 + ], + [ + 66303, + 59171 + ], + [ + 66303, + 59203 + ] + ], + "triple": 0 + } + ], + "inherited_support_sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4", + "inherited_support_source": "research/h6-independent-audit/walsh/results.json", + "module_count": 4800, + "module_rule": "For each acute a-triple, orthogonal b-pair, epsilon=+-1, port(group,z)=(a_group,epsilon*sigma_group*b_z). Source product ID2160+240*a+2*b+int(sign<0).", + "redesigned_disjoint_r3_private_residual": { + "all_positive_L_active_data_gap_lower": "83604513235298010226025030954220284651189172104497575035491487/2015625000000000000000000000000000000000000000000000000000000000", + "assumptions": "Arbitrary weights per disjoint6-port r3 module, no within-own-group coefficient, D=0 on pure ports. All residual dependence returns through private episodes, each granted ideal rank1 and free ordinary banks.", + "rank_I_minus_D_lower": 11760, + "rank_residual_lower": 10944, + "total_private_C_lower": 24816 + }, + "scope": "Actual disjoint r3 tiling with exact residual set, actual edge-helper completion and scoped private-residual failures. Overlapping/composed dynamic modules, mutable residual networks, changed source/target schedules and different centre interfaces remain open. No new kappa or full physical/approximate supplier admission.", + "source_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "PASS_ACTUAL_FULL_ROOT_PRODUCT_DYNAMIC_TILING_AND_PAID_RESIDUAL_NO_NEW_KAPPA", + "triple_gauge_signs": [ + [ + 1, + -1, + -1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + -1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + -1, + -1 + ], + [ + 1, + -1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 1, + 1 + ] + ], + "uncovered_exceptional_entries": 3306240, + "uncovered_ordered_nonzero_entries": 480222720, + "uncovered_unit_entries": 476916480, + "untiled_ports": { + "indices": [ + 0, + 2159 + ], + "meaning": "Both1080-port pure norm4 blocks; complete interval0<=i<2160." + } +} diff --git a/research/h6-partial-frame-networks/cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz b/research/h6-partial-frame-networks/cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz new file mode 100644 index 0000000000..ee5f9b60f1 Binary files /dev/null and b/research/h6-partial-frame-networks/cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz differ diff --git a/research/h6-partial-frame-networks/cyclic/frozen/WALSH-RESULTS.json b/research/h6-partial-frame-networks/cyclic/frozen/WALSH-RESULTS.json new file mode 100644 index 0000000000..4f7a9294c9 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/WALSH-RESULTS.json @@ -0,0 +1,968 @@ +{ + "all_attainable_scalar_identities": [ + { + "scaled_48_I_minus_K": 15, + "t": -3 + }, + { + "scaled_48_I_minus_K": 0, + "t": -2 + }, + { + "scaled_48_I_minus_K": -3, + "t": -1 + }, + { + "scaled_48_I_minus_K": 0, + "t": 0 + }, + { + "scaled_48_I_minus_K": 3, + "t": 1 + }, + { + "scaled_48_I_minus_K": 0, + "t": 2 + }, + { + "scaled_48_I_minus_K": -15, + "t": 3 + }, + { + "scaled_48_I_minus_K": 0, + "t": 4 + } + ], + "alternating_form": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "binary_rank": 16, + "compensation_nonzeros": 480337920, + "compensation_row_degree": [ + 15488, + 15872 + ], + "distinct_labels": 14670, + "elapsed_seconds": 22.66295995900873, + "environment": { + "chunk_rows": 256, + "numpy": "2.3.5", + "platform": "macOS-26.5.2-arm64-arm-64bit", + "python": "3.12.14" + }, + "exceptional_abs_t_3_pairs": 3363840, + "exceptional_share_of_nonzeros_exact": "73/10424", + "exceptional_share_of_nonzeros_percent": 0.7003069838833461, + "inputs_sha256": { + "h6-banked-breakeven/README.md": "0ca2f3011d848bb216584d932d23d587df8c637fbe755cf0697c4e11dcb5663f", + "h6-banked-breakeven/structure.py": "75148243f205aa9d0269c6f125782971929e253c37e1789131a73b822a7966fa", + "h6-banked-breakeven/walsh.py": "76fb9a5d98b3f2d86d092be297e2c176a4fc0d7c606c29bb2942730353513fb4", + "niemeier-lattices/code/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + "label_multiplicity_histogram": [ + [ + 2, + 14400 + ], + [ + 8, + 270 + ] + ], + "label_span_witness_indices": [ + 0, + 3, + 12, + 13, + 16, + 45, + 126, + 287, + 1080, + 1083, + 1092, + 1093, + 1096, + 1125, + 1206, + 1367 + ], + "negative_control_max_absolute_errors": { + "omit_exception": "1/2", + "reverse_exception_sign": "1", + "use_raw_dot_instead_of_t": "9/16" + }, + "norm4_label_count_per_block": 135, + "norm4_label_multiplicity": 8, + "ordered_pairs_checked": 958521600, + "p_canonical_little_endian_int64_sha256": "db3985eef4000ae64e63b1c80f405d0a377980c45191c2beadda5bf69e9d009d", + "p_npy_sha256": "349e84668d1528783aa22bc650837533bcc6134052d9dbfba87fb05aa54911fd", + "pairing_histogram": { + "-3": 568960, + "-2": 37564800, + "-1": 200240000, + "0": 365458320, + "1": 276734080, + "2": 75129600, + "3": 2794880, + "4": 30960 + }, + "ports": 30960, + "proposal_seed_3_principal_minor_indices": [ + 8197, + 19231, + 2913, + 14830, + 5553, + 26903, + 18019, + 7328, + 10283, + 1219, + 5613, + 24799, + 2650, + 25112, + 4945, + 13407 + ], + "proposal_seed_3_principal_minor_inverse": [ + [ + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 1 + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1 + ], + [ + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 0 + ], + [ + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ] + ], + "root_basis_doubled_vectors": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 2, + -2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + -2, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + -2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + -2, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 1 + ] + ], + "root_basis_indices": [ + 0, + 1, + 2, + 6, + 12, + 20, + 30, + 42 + ], + "root_gram": [ + [ + 2, + 0, + -1, + 0, + 0, + 0, + 0, + -1 + ], + [ + 0, + 2, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + -1, + 2, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + -1, + 2, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + -1, + 2, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + -1, + 2, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + -1, + 2, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ] + ], + "root_gram_determinant": 1, + "root_gram_inverse": [ + [ + 14, + 10, + 20, + 16, + 12, + 8, + 4, + 7 + ], + [ + 10, + 8, + 15, + 12, + 9, + 6, + 3, + 5 + ], + [ + 20, + 15, + 30, + 24, + 18, + 12, + 6, + 10 + ], + [ + 16, + 12, + 24, + 20, + 15, + 10, + 5, + 8 + ], + [ + 12, + 9, + 18, + 15, + 12, + 8, + 4, + 6 + ], + [ + 8, + 6, + 12, + 10, + 8, + 6, + 3, + 4 + ], + [ + 4, + 3, + 6, + 5, + 4, + 3, + 2, + 2 + ], + [ + 7, + 5, + 10, + 8, + 6, + 4, + 2, + 4 + ] + ], + "root_label_count": 120, + "scope": "Finite exhaustive parity and compensation identities; algebraic rank-16 proof; no arithmetic circuit, helper-loading, or kappa claim.", + "status": "PASS_EXHAUSTIVE_INTEGER_H6_WALSH", + "walsh_full_dimension": 65536, + "walsh_orthogonal_normalization_divisor": 256 +} diff --git a/research/h6-partial-frame-networks/cyclic/frozen/cyclic_mixed.py b/research/h6-partial-frame-networks/cyclic/frozen/cyclic_mixed.py new file mode 100644 index 0000000000..ecff49d97e --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/cyclic_mixed.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +"""Actual full-rank H6 subfamilies with cyclic partial-frame mixed channels. + +Two ± source channels per group, all ordinary dirty, no private compensation +return. Frame visits increase along cyclic arcs. Whole K+C word included. +Finite r=2..7 E8 family; abstract arc lemma is written separately. +""" +from fractions import Fraction as F +from pathlib import Path +import importlib.util, json, hashlib + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location('mixed_base',HERE/'mixed_rectangle.py') +m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m) +need = m.need + + +def fixture(r): + n = 2*r + beta = (2,2,0,0,0,0,0,0) + gamma = (2,-2,0,0,0,0,0,0) + aa = [] + for g in range(r): + a = [0]*8; a[0] = 2; a[g+1] = -2; aa.append(tuple(a)) + ports = [a+b for a in aa for b in (beta,gamma)] + labels,indices = m.actual_labels(ports) + planes = [m.basis(labels[2*g:2*g+2]) for g in range(r)] + arcs = {(g,k):m.basis(v for j in range(k) for v in planes[(g+j)%r]) + for g in range(r) for k in range(1,r)} + need(all(len(f) == k+1 for (g,k),f in arcs.items()),'actual arc dimensions') + need(all(m.included(arcs[g,k],m.perp(labels[2*((g+k)%r)+z])) + for g in range(r) for k in range(1,r) for z in range(2)), 'whole opposite target cap') + need(all(m.included(arcs[g,k],arcs[g,k+1]) for g in range(r) for k in range(1,r-1)), 'helper nested arcs') + need(all(m.included(arcs[(t-k)%r,k],arcs[(t-k-1)%r,k+1]) + for t in range(r) for k in range(1,r-1)), 'target nested preceding arcs') + k = [[F(m.dot(p,q)**3-4*m.dot(p,q),48) for q in ports] for p in ports] + c = [[F(int(i == j))-k[i][j] for j in range(n)] for i in range(n)] + need(c == [[F(0) if i//2 == j//2 else F(-5 if i%2 == j%2 else 1,16) + for j in range(n)] for i in range(n)], 'actual full-rank block compensation') + # L is blockwise ± source mixing; R scatters each channel to all other groups. + l = [[F(0)]*n for _ in range(n)] + decoder = [[F(0)]*n for _ in range(n)] + for g in range(r): + l[2*g][2*g] = l[2*g][2*g+1] = 1 + l[2*g+1][2*g] = 1; l[2*g+1][2*g+1] = -1 + for t in range(n): + if t//2 != g: + decoder[t][2*g] = -F(1,8) + decoder[t][2*g+1] = F(3 if t%2 else -3,16) + need(all(sum(decoder[i][g]*l[g][j] for g in range(n)) == c[i][j] + for i in range(n) for j in range(n)), 'exact C=R L including exceptional t3') + starts = {f'x{i}':m.basis([labels[i]]) for i in range(n)} + starts.update({f'y{i}':() for i in range(n)}) + starts.update({f'c{i}':() for i in range(n)}) + starts.update({f'h{i}':() for i in range(n)}) + ends = {a:m.FULL for a in starts}; ends.update({f'y{i}':m.perp(labels[i]) for i in range(n)}) + ev = [] + def add(dst,src,q,tag): + if q:ev.append({'op':'add','dst':dst,'src':src,'q':str(q),'tag':tag}) + def climb(reg,frame,tag):ev.append({'op':'climb','register':reg,'frame':list(frame),'tag':tag}) + for t in range(n): + for j in range(n): + add(f'y{t}',f'h{j}',-decoder[t][j],'comp_prefix') + add(f'y{t}',f'c{j}',-k[t][j],'K_prefix') + for g in range(r): + for i in range(2*g,2*g+2):climb(f'x{i}',planes[g],'source_plane') + for j in range(2*g,2*g+2): + climb(f'h{j}',planes[g],'mixed_gather_plane') + for i in range(2*g,2*g+2):add(f'h{j}',f'x{i}',l[j][i],'comp_gather') + for i in range(n):climb(f'x{i}',m.FULL,'source_full') + for i in range(n): + climb(f'c{i}',m.FULL,'K_center_full');add(f'c{i}',f'x{i}',F(1),'K_gather') + for j in range(n):ev.append({'op':'private','center':f'c{j}', + 'targets':[[f'y{i}',str(k[i][j])] for i in range(n) if k[i][j]],'tag':'K_private'}) + for i in range(n):add(f'c{i}',f'x{i}',-F(1),'K_restore') + for depth in range(1,r): + for g in range(r): + target = (g+depth)%r + frame = arcs[g,depth] + for j in range(2*g,2*g+2):climb(f'h{j}',frame,'helper_arc') + for t in range(2*target,2*target+2): + climb(f'y{t}',frame,'target_arc') + for j in range(2*g,2*g+2):add(f'y{t}',f'h{j}',decoder[t][j],'comp_scatter') + for i in range(n):climb(f'y{i}',m.perp(labels[i]),'target_cap') + for j in range(n): + climb(f'h{j}',m.FULL,'mixed_restore_full') + for i in range(n):add(f'h{j}',f'x{i}',-l[j][i],'comp_restore') + return {'r':r,'N':n,'ports_doubled':ports,'source_indices':indices,'labels':labels, + 'planes':[list(x) for x in planes],'arcs':{str(g)+':'+str(d):list(f) for (g,d),f in arcs.items()}, + 'K':[[str(q) for q in row] for row in k],'C':[[str(q) for q in row] for row in c], + 'L':[[str(q) for q in row] for row in l],'R':[[str(q) for q in row] for row in decoder], + 'starts':{a:list(f) for a,f in starts.items()},'ends':{a:list(f) for a,f in ends.items()},'events':ev} + + +def matrix_check(fix): + # Independent closed block products, rather than a scalar-event interpreter. + n = fix['N']; dim = 4*n + k = [[F(q) for q in row] for row in fix['K']] + l = [[F(q) for q in row] for row in fix['L']] + rr = [[F(q) for q in row] for row in fix['R']] + def eye():return [[F(int(i == j)) for j in range(dim)] for i in range(dim)] + rows = eye(); dual = eye() + def block(entries): + # All entries in one block have pairwise-zero products. + for dst,src,q in entries: + rows[dst] = [x+q*y for x,y in zip(rows[dst],rows[src])] + dual[src] = [x-q*y for x,y in zip(dual[src],dual[dst])] + block([(n+i,2*n+j,-k[i][j]) for i in range(n) for j in range(n) if k[i][j]] + +[(n+i,3*n+j,-rr[i][j]) for i in range(n) for j in range(n) if rr[i][j]]) + block([(3*n+i,j,l[i][j]) for i in range(n) for j in range(n) if l[i][j]]) + block([(2*n+i,i,F(1)) for i in range(n)]) + block([(n+i,2*n+j,k[i][j]) for i in range(n) for j in range(n) if k[i][j]]) + block([(2*n+i,i,-F(1)) for i in range(n)]) + block([(n+i,3*n+j,rr[i][j]) for i in range(n) for j in range(n) if rr[i][j]]) + block([(3*n+i,j,-l[i][j]) for i in range(n) for j in range(n) if l[i][j]]) + a,b = eye(),eye() + for i in range(n):a[n+i][i] += 1;b[i][n+i] -= 1 + need(rows == a and dual == b,'independent all-input block closure') + # C=(J-I) tensor B: its eigenvalues are -(r-1)/4,1/4, + # -3(r-1)/8,3/8, all nonzero. K=I-C is also invertible. + r=fix['r'] + ev=[-F(r-1,4),F(1,4),-F(3*(r-1),8),F(3,8)] + need(all(x and x != 1 for x in ev),'C and restricted K both full rank') + return 2*dim*dim + + +def main(): + results=[];controls=[] + for r in range(2,8): + fix=fixture(r);n=2*r + forward=m.replay(fix);dual=m.replay(fix,True) + need(forward['rank_mass'] == dual['rank_mass'] == 83*n,'whole paid rank mass') + need(forward['scalar_primitives_before_real_doubling'] == n*(72*r-37),'whole forward Horner bill') + need(dual['scalar_primitives_before_real_doubling'] == n*(72*r-34),'whole dual Horner bill') + independent=matrix_check(fix) + for tag in ('comp_prefix','comp_gather','comp_scatter','comp_restore','K_prefix','K_private','helper_arc','target_arc'): + for d in (False,True): + try:m.replay(fix,d,tag) + except ValueError as e:controls.append({'r':r,'omit':tag,'dual':d,'gate':str(e)}) + else: + # At r=2 helpers already occupy the only U, so its redundant + # arc CLIMB is intentionally unnecessary. + need(r == 2 and tag == 'helper_arc','meaningful mutation rejected') + results.append({'r':r,'N':n,'C_rank':n,'restricted_K_rank':n,'compensation_helpers':n, + 'edge_baseline':4*r*(r-1),'private_K_rank':17*n, + 'independent_operator_entries':independent, + 'forward':forward,'dual':dual,'fixture':fix}) + out={'status':'PASS_ACTUAL_H6_CYCLIC_MIXED_FULL_RANK_SUBFAMILIES_NO_NEW_KAPPA', + 'source_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','cases':results,'controls':controls, + 'limits':'Actual E8 examples r=2..7 only, N=4..14. Whole subfamily K has rankN and private C=17N, hence fails standalone coverage for every L. Does not give the full30960-port network or permit block tiling with the unchanged816-center K.', + 'source_sha256':hashlib.sha256((HERE/'mixed_rectangle.py').read_bytes()).hexdigest()} + (HERE/'CYCLIC-MIXED-RESULT.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']+' r=2..7 controls='+str(len(controls))) + for x in results:print('r',x['r'],'N',x['N'],'helpers',x['compensation_helpers'],'edge',x['edge_baseline'],'rank',x['forward']['rank_mass'],'primitives',x['forward']['scalar_primitives_before_real_doubling'],x['dual']['scalar_primitives_before_real_doubling']) + + +if __name__=='__main__':main() diff --git a/research/h6-partial-frame-networks/cyclic/frozen/dynamic_cyclic.py b/research/h6-partial-frame-networks/cyclic/frozen/dynamic_cyclic.py new file mode 100644 index 0000000000..2c942dfebe --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/dynamic_cyclic.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""Mutable cyclic readers: exact input transport and dirty cleanup. + +Each reader accumulates successive source groups at nested frames, then +delivers once to the excluded group. Actual E8 cases r=2..7 only. No full +H6 arc network or improved kappa is inferred from conditional tariffs. +""" +from fractions import Fraction as F +from pathlib import Path +import importlib.util +import json + +HERE = Path(__file__).resolve().parent + + +def load(name, file): + spec = importlib.util.spec_from_file_location(name, HERE/file) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +c = load('dynamic_static_cyclic', 'cyclic_mixed.py') +m = c.m +b = load('dynamic_exact_budget', 'optimistic_budget.py') +need = m.need + + +def fixture(r): + fix = c.fixture(r) + n = fix['N'] + k = [[F(q) for q in row] for row in fix['K']] + planes = [tuple(p) for p in fix['planes']] + arc = {(g, depth): tuple(fix['arcs'][str(g)+':'+str(depth)]) + for g in range(r) for depth in range(1, r)} + # L is now the cyclic all-but-excluded prefix accumulation. R sends + # each final packet to only that excluded target pair. + ell = [[F(0)]*n for _ in range(n)] + decoder = [[F(0)]*n for _ in range(n)] + for g in range(r): + for depth in range(r-1): + source = (g+depth) % r + ell[2*g][2*source] = ell[2*g][2*source+1] = 1 + ell[2*g+1][2*source] = 1 + ell[2*g+1][2*source+1] = -1 + t = (g-1) % r + for z in range(2): + decoder[2*t+z][2*g] = -F(1, 8) + decoder[2*t+z][2*g+1] = F(3 if z else -3, 16) + need(all(sum(decoder[i][g]*ell[g][j] for g in range(n)) + == F(fix['C'][i][j]) for i in range(n) for j in range(n)), + 'dynamic exact coefficient identity C=R L') + events = [] + + def add(dst, src, q, tag): + if q: + events.append({'op': 'add', 'dst': dst, 'src': src, + 'q': str(q), 'tag': tag}) + + def climb(reg, frame, tag): + events.append({'op': 'climb', 'register': reg, + 'frame': list(frame), 'tag': tag}) + + for t in range(n): + for j in range(n): + add(f'y{t}', f'h{j}', -decoder[t][j], 'comp_prefix') + add(f'y{t}', f'c{j}', -k[t][j], 'K_prefix') + # At depth0 each source pair and its reader pair meet at U_g. + # At depth d>0 source group j visits F(j-d,d+1), including itself. + # Its previous visit F(j-d+1,d) is a subspace of this new arc. + for depth in range(r-1): + for g in range(r): + source = (g+depth) % r + frame = arc[g, depth+1] + for z in range(2): + climb(f'x{2*source+z}', frame, 'source_read_arc') + climb(f'h{2*g+z}', frame, 'mutable_reader_arc') + for z in range(2): + add(f'h{2*g}', f'x{2*source+z}', F(1), 'mutable_read') + add(f'h{2*g+1}', f'x{2*source+z}', F(1 if z == 0 else -1), 'mutable_read') + for i in range(n): + climb(f'x{i}', m.FULL, 'source_full') + climb(f'c{i}', m.FULL, 'K_center_full') + add(f'c{i}', f'x{i}', F(1), 'K_gather') + for j in range(n): + events.append({'op': 'private', 'center': f'c{j}', + 'targets': [[f'y{i}', str(k[i][j])] for i in range(n) if k[i][j]], + 'tag': 'K_private'}) + for i in range(n): + add(f'c{i}', f'x{i}', -F(1), 'K_restore') + for g in range(r): + t = (g-1) % r + for z in range(2): + climb(f'y{2*t+z}', arc[g, r-1], 'target_final_arc') + for channel in range(2): + add(f'y{2*t+z}', f'h{2*g+channel}', + decoder[2*t+z][2*g+channel], 'comp_scatter') + climb(f'y{2*t+z}', tuple(fix['ends'][f'y{2*t+z}']), 'target_cap') + for j in range(n): + climb(f'h{j}', m.FULL, 'reader_restore_full') + for i in range(n): + add(f'h{j}', f'x{i}', -ell[j][i], 'comp_restore') + fix.update(L=[[str(q) for q in row] for row in ell], + R=[[str(q) for q in row] for row in decoder], events=events, + mechanism='mutable cyclic prefix readers; one final delivery') + return fix + + +def conditional_tariffs(): + rows = [] + for r in range(2, 8): + source = [1]*(r-1)+[17-r] + target = [r, 16-r] + helper = [2]+[1]*(r-2)+[17-r] + for L in range(3, 34, 2): + row = b.model(L, source, target, helper, b.N) + rows.append({'r': r, 'L': L, 'm': row['m'], 'q': row['q'], + 'pad': row['pad'], 'source': source, 'target': target, + 'helper': helper, 'R': b.N, 'stock_W': str(row['W']), + 'K_ordinary_roles': b.KC, 'K_private_C': b.KBILL, + 'coverage_deficit': row['D'], + 'rank_histogram': {r: str(n) for r, n in sorted(row['H'].items())}, + 'targets': [dict(b.target_row(row, k), + helper_boundary=b.helper_boundary(row, k)) + for k in map(F, ('.002', '.003', '.005'))]}) + return rows + + +def main(): + cases, controls = [], [] + for r in range(2, 8): + fix = fixture(r) + n = fix['N'] + forward, dual = m.replay(fix), m.replay(fix, True) + need(forward['rank_mass'] == dual['rank_mass'] == 83*n, + 'whole dynamic word rank mass') + need(forward['scalar_primitives_before_real_doubling'] == n*(54*r-1), + 'whole dynamic forward primitive bound') + need(dual['scalar_primitives_before_real_doubling'] == n*(54*r+2), + 'whole dynamic dual primitive bound') + independent = c.matrix_check(fix) + for tag in ('mutable_read', 'comp_prefix', 'comp_scatter', + 'comp_restore', 'K_private', 'source_read_arc', + 'mutable_reader_arc', 'target_final_arc'): + for inverse in (False, True): + try: + m.replay(fix, inverse, tag) + except ValueError as err: + controls.append({'r': r, 'omit': tag, 'dual': inverse, + 'gate': str(err)}) + else: + raise ValueError('meaningful dynamic defect accepted '+tag) + cases.append({'r': r, 'N': n, 'C_rank': n, 'restricted_K_rank': n, + 'ordinary_mutable_readers': n, 'compensation_private_rank': 0, + 'source_path': [1]*(r-1)+[17-r], + 'target_path': [r, 16-r], + 'helper_path': [2]+[1]*(r-2)+[17-r], + 'forward': forward, 'dual': dual, + 'independent_operator_entries': independent, 'fixture': fix}) + tariffs = conditional_tariffs() + out = {'status': 'PASS_ACTUAL_MUTABLE_CYCLIC_H6_READERS_NO_NEW_KAPPA', + 'source_pin': b.PIN, 'cases': cases, 'controls': controls, + 'conditional_full_H6_tariffs': tariffs, + 'limits': 'Actual E8 examples r=2..7,N=4..14. Sources really traverse the declared nested read arcs; targets stayZERO through K and have one final arc visit. Full subfamily K is rankN with private C=17N, so standalone coverage fails for every L. Full-domain tariff assumes an unconstructed common-frame incidence network using N such channels and the unchanged816-center full K. Pure-block couplings, whole H6 geometry, physical allocation, approximate-child precision and outer BIT closure remain unproved. Tariff passing is not a kappa claim.'} + (HERE/'DYNAMIC-CYCLIC-RESULT.json').write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + print(out['status']+' cases=6 controls='+str(len(controls))) + for case in cases: + print('r', case['r'], 'N', case['N'], 'rank', case['forward']['rank_mass'], + 'primitives', case['forward']['scalar_primitives_before_real_doubling'], + case['dual']['scalar_primitives_before_real_doubling']) + for r in (3, 7): + candidates = [row for row in tariffs if row['r'] == r] + for k in ('1/500', '3/1000', '1/200'): + best = max(candidates, + key=lambda row: F(next(t for t in row['targets'] if t['target'] == k)['raw_slack']['lower'])) + t = next(t for t in best['targets'] if t['target'] == k) + print('conditional r', r, 'target', k, 'bestL', best['L'], + 'maxR', t['helper_boundary']['largest_nonnegative_R'], + 'M', t['normalized_moment']['lo']) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/cyclic/frozen/e8_cubed.py b/research/h6-partial-frame-networks/cyclic/frozen/e8_cubed.py new file mode 100644 index 0000000000..d4444d142f --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/e8_cubed.py @@ -0,0 +1,302 @@ +"""Exact E8^3 norm-four shell, binary fit, and dyadic scalar factorization. + +Coordinates are doubled: roots have squared norm 8 and the norm-four shell +has squared norm 16. All rank calculations are over finite fields; no +floating-point rank or sampled all-pairs assertion is used. +""" +from collections import Counter +from fractions import Fraction +from itertools import combinations, combinations_with_replacement, product +import hashlib +import json +import numpy as np + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def insert_binary(basis, value): + value = int(value) + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + return True + return False + + +def inverse_binary(matrix): + size = len(matrix) + work = np.concatenate((matrix.copy(), np.eye(size, dtype=np.uint8)), axis=1) + for col in range(size): + choices = np.flatnonzero(work[col:, col]) + require(len(choices) > 0, 'Invertible binary Gram matrix') + pivot = col + int(choices[0]) + work[[col, pivot]] = work[[pivot, col]] + for row in range(size): + if row != col and work[row, col]: + work[row] ^= work[col] + return work[:, size:] + + +def symplectic_transform(matrix): + size = len(matrix) + require(size % 2 == 0 and np.array_equal(matrix, matrix.T) + and not np.diag(matrix).any(), 'Alternating binary form') + transform = np.eye(size, dtype=np.uint8) + work = matrix.copy() + for first in range(0, size, 2): + choices = np.argwhere(work[first:, first:]) + require(len(choices) > 0, 'Nondegenerate alternating form') + a, b = (int(value) + first for value in choices[0]) + for current, target in ((a, first), (b if b != first else a, first + 1)): + work[[current, target]] = work[[target, current]] + work[:, [current, target]] = work[:, [target, current]] + transform[[current, target]] = transform[[target, current]] + for row in range(first + 2, size): + left, right = int(work[row, first + 1]), int(work[row, first]) + if left: + transform[row] ^= transform[first] + if right: + transform[row] ^= transform[first + 1] + work = (transform @ matrix @ transform.T) & 1 + target = np.zeros_like(matrix) + for first in range(0, size, 2): + target[first, first + 1] = target[first + 1, first] = 1 + require(np.array_equal(work, target), 'Symplectic basis identity') + return transform + + +def canonical_lines(vectors): + array = np.asarray(vectors, dtype=np.int16) + first = np.argmax(array != 0, axis=1) + signs = np.where(array[np.arange(len(array)), first] > 0, 1, -1) + return np.unique(array * signs[:, None], axis=0).astype(np.int16) + + +def e8_shells(): + roots, fourth = [], [] + for positions in combinations(range(8), 2): + for signs in product((-2, 2), repeat=2): + row = np.zeros(8, dtype=np.int16) + row[list(positions)] = signs + roots.append(row) + for signs in product((-1, 1), repeat=8): + if sum(signs) % 4 == 0: + roots.append(np.array(signs, dtype=np.int16)) + for coordinate in range(8): + for sign in (-4, 4): + row = np.zeros(8, dtype=np.int16) + row[coordinate] = sign + fourth.append(row) + for positions in combinations(range(8), 4): + for signs in product((-2, 2), repeat=4): + row = np.zeros(8, dtype=np.int16) + row[list(positions)] = signs + fourth.append(row) + for coordinate in range(8): + for signs in product((-1, 1), repeat=8): + row = np.array(signs, dtype=np.int16) + row[coordinate] *= 3 + if int(row.sum()) % 4 == 0: + fourth.append(row) + require(len(roots) == 240 and len(fourth) == 2160, 'E8 shell vector counts') + roots, fourth = canonical_lines(roots), canonical_lines(fourth) + require(roots.shape == (120, 8) and fourth.shape == (1080, 8), 'E8 line counts') + for rows, norm in ((roots, 8), (fourth, 16)): + require(np.all((rows * rows).sum(axis=1) == norm), 'Exact E8 shell norms') + require(np.all(rows.sum(axis=1) % 4 == 0), 'Doubled E8 parity condition') + require(np.all((rows % 2) == (rows[:, :1] % 2)), 'Doubled E8 coordinate parity') + return roots, fourth + + +def construct_shell(): + roots, fourth = e8_shells() + pieces, profiles = [], [] + for block in range(3): + rows = np.zeros((1080, 24), dtype=np.int16) + rows[:, 8 * block:8 * (block + 1)] = fourth + pieces.append(rows) + profiles.extend([1 << block] * len(rows)) + for first, second in combinations(range(3), 2): + rows = np.zeros((28800, 24), dtype=np.int16) + rows[:, 8 * first:8 * (first + 1)] = np.repeat(roots, 240, axis=0) + rows[:, 8 * second:8 * (second + 1)] = ( + np.tile(np.repeat(roots, 2, axis=0), (120, 1)) + * np.tile([1, -1], 14400)[:, None]) + pieces.append(rows) + profiles.extend([(1 << first) | (1 << second)] * len(rows)) + rows = np.concatenate(pieces) + require(rows.shape == (89640, 24), 'E8 cubed norm-four line count') + require(np.all((rows * rows).sum(axis=1) == 16), 'E8 cubed shell norms') + require(len({row.tobytes() for row in rows}) == len(rows), 'Distinct canonical lines') + first = np.argmax(rows != 0, axis=1) + require(np.all(rows[np.arange(len(rows)), first] > 0), 'Canonical antipodal orientation') + return roots, fourth, rows, np.array(profiles, dtype=np.uint8) + + +def binary_labels(roots, ports): + blocks = ports.shape[1] // 8 + dimension = 8 * blocks + 1 + integer_gram = roots @ roots.T + require(not (integer_gram % 4).any(), 'Integral E8 lattice pairings') + gram = ((integer_gram // 4) & 1).astype(np.uint8) + work, available, selected = gram.copy(), list(range(120)), [] + while work[np.ix_(available, available)].any(): + a, b = np.argwhere(work[np.ix_(available, available)])[0] + a, b = available[int(a)], available[int(b)] + selected.extend((a, b)) + left, right = work[a].copy(), work[b].copy() + work ^= np.outer(left, right) ^ np.outer(right, left) + available.remove(a) + available.remove(b) + require(len(selected) == 8, 'E8 mod-two rank eight') + basis = roots[selected] + inverse = inverse_binary(gram[np.ix_(selected, selected)]) + coordinates = np.zeros((len(ports), dimension - 1), dtype=np.uint8) + form = np.zeros((dimension - 1, dimension - 1), dtype=np.uint8) + for block in range(blocks): + pairings = ports[:, 8 * block:8 * (block + 1)] @ basis.T + require(not (pairings % 4).any(), 'Integral shell-basis pairings') + coordinates[:, 8 * block:8 * (block + 1)] = (pairings // 4) & 1 + form[8 * block:8 * (block + 1), 8 * block:8 * (block + 1)] = inverse + even_gram = np.ones((dimension - 1, dimension - 1), dtype=np.uint8) ^ np.eye(dimension - 1, dtype=np.uint8) + change = (inverse_binary(symplectic_transform(form)) + @ symplectic_transform(even_gram)) & 1 + require(np.array_equal((change @ even_gram @ change.T) & 1, form), + 'Standard-dot even-space isometry') + even_basis = np.concatenate((np.eye(dimension - 1, dtype=np.uint8), + np.ones((dimension - 1, 1), dtype=np.uint8)), axis=1) + labels = ((coordinates @ change @ even_basis) & 1) ^ 1 + require(np.all(labels.sum(axis=1) % 2 == 1), 'Odd standard-dot labels') + packed = labels.astype(np.uint32) @ (1 << np.arange(dimension, dtype=np.uint32)) + spanning, witnesses = {}, [] + for index, value in enumerate(packed): + if insert_binary(spanning, value): + witnesses.append(index) + require(len(spanning) == dimension, 'Full binary label span') + samples = np.unique(np.concatenate((witnesses, np.linspace(0, len(ports) - 1, 32, dtype=int)))) + for index in samples: + dots = ports @ ports[index] + require(not (dots % 4).any(), 'Integral shell pairings') + require(np.array_equal((labels @ labels[index]) & 1, 1 ^ ((dots // 4) & 1)), + 'Exact label identity on additional diagnostic rows') + return labels, packed, dict(dimension=dimension, root_basis_indices=selected, + root_basis_vectors=basis.tolist(), alternating_gram=form.tolist(), + standard_dot_coordinate_map=((change @ even_basis) & 1).tolist(), + span_witnesses=witnesses, diagnostic_rows=samples.tolist(), + identity='p(u) dot p(v) = 1 + (u dot v / 4) mod 2', + universal_proof=f'The eight E8 basis roots have an odd integral Gram determinant. In lattice pairing coordinates its rational inverse reduces to the displayed binary inverse. {"Three" if blocks == 3 else "Two"} orthogonal blocks give the alternating rank-{dimension - 1} form; the verified even-space isometry and the orthogonal all-ones vector realize it by the standard dot product in dimension {dimension}.') + + +def modular_rank_witnesses(rows, prime=101): + basis, selected = {}, [] + for index, raw in enumerate(rows): + row = np.asarray(raw, dtype=np.int64).copy() % prime + for pivot in sorted(basis): + row = (row - row[pivot] * basis[pivot]) % prime + nonzero = np.flatnonzero(row) + if not len(nonzero): + continue + pivot = int(nonzero[0]) + basis[pivot] = row * pow(int(row[pivot]), -1, prime) % prime + selected.append(index) + if len(basis) == rows.shape[1]: + break + return selected + + +def real_rank(roots, fourth): + witnesses = {} + for name, rows, degree, expected in ( + ('pure_cubics', fourth, 3, 120), + ('root_quadratics', roots, 2, 36), ('root_linears', roots, 1, 8)): + monomials = list(combinations_with_replacement(range(8), degree)) + features = np.stack([np.prod(rows[:, monomial].astype(np.int64), axis=1) + for monomial in monomials], axis=1) + selected = modular_rank_witnesses(features) + require(len(selected) == expected, f'Exact rational feature rank: {name}') + witnesses[name] = dict(prime=101, rank=expected, independent_rows=selected) + trace_norm = (Fraction(1) + Fraction(23, 3)) / 256 + correction_eigenvalue = 1 - 64 * trace_norm + require(trace_norm == Fraction(13, 384) and correction_eigenvalue == Fraction(-7, 6), + 'Nonzero trace-correction eigenvalue') + return dict(real_kernel_rank=2088, pure_cubic_features=360, mixed_cubic_features=1728, + omitted_three_block_features=512, finite_rank_witnesses=witnesses, + trace_correction_eigenvalue=str(correction_eigenvalue), signature=[2064, 24], + proof='The pure norm-four sectors make all 3 times 120 pure cubics independent. On each root-pair sector, changing one block sign separates the two mixed parities; ranks 36 and 8 give 288 independent features per ordered block pair. Thus the 2088 retained cubic columns are independent. Let D contain cubic multinomial coefficients and represent u_i as (sum_j u_i*u_j^2)/16. The coefficient matrix is (D-64 L L^T)/3072, with L^T D^-1 L=(13/384)I_24. Its rank-24 correction has nonzero eigenvalue -7/6, proving rank 2088 and the displayed signature.') + + +def support_orbit(ports, packed, name, coordinates=None): + if coordinates is not None: + values = np.prod(ports[:, coordinates].astype(np.int32), axis=1) + else: + value = ports[:, 0].astype(np.int32) + quotient = (value ** 3 - value) // 3 + values = 5 * value - quotient if name == 'unary_f' else quotient - value + support = np.flatnonzero(values) + basis, witnesses = {}, [] + for index in support: + if insert_binary(basis, packed[index]): + witnesses.append(int(index)) + return dict(name=name, representative_coordinates=list(coordinates) if coordinates else [0], + support_size=len(support), binary_span=len(basis), independent_ports=witnesses) + + +def factorization(ports, packed): + orbits = [support_orbit(ports, packed, name, coordinates) for name, coordinates in ( + ('pure_cube', (0, 0, 0)), ('pure_repeated', (0, 0, 1)), + ('pure_distinct', (0, 1, 2)), ('mixed_repeated', (0, 0, 8)), + ('mixed_distinct', (0, 1, 8)), ('unary_f', None), ('unary_g', None))] + require([orbit['binary_span'] for orbit in orbits] == [25, 25, 25, 17, 17, 25, 25], + 'Complete binary support spans for each center orbit') + for left, right in product(range(-4, 5), repeat=2): + q_left, q_right = (left ** 3 - left) // 3, (right ** 3 - right) // 3 + require(left ** 3 * right ** 3 - 64 * left * right == + 3 * (-(5 * left - q_left) * (5 * right - q_right) + + 4 * (q_left - left) * (q_right - right)), + 'Dyadic unary factorization identity') + monomials = [indices for indices in combinations_with_replacement(range(24), 3) + if len({index // 8 for index in indices}) <= 2] + counts = Counter() + for indices in monomials: + blocks = len({index // 8 for index in indices}) + distinct = len(set(indices)) + counts[(blocks, distinct)] += 1 + require(dict(counts) == {(1, 1): 24, (1, 2): 168, (1, 3): 168, + (2, 2): 384, (2, 3): 1344}, 'Cubic feature orbit counts') + return dict(center_count=2112, center_width_histogram={'25': 384, '17': 1728}, + center_bill=38976, literal_cubic_only_bill=38376, + literal_cubic_only_bill_scope='Omits the linear correction; not a certified factorization bill.', + support_orbits=orbits, + dyadic_unary_identity='q(u)=(u^3-u)/3; (u^3*v^3-64*u*v)/3072 = (-(5*u-q(u))*(5*v-q(v))+4*(q(u)-u)*(q(v)-v))/1024', + diagonal_coefficients={'unary_f': '-1/1024', 'unary_g': '1/256', + 'repeated_cubic': '1/1024', 'distinct_cubic': '1/512'}, + proof='Expand (u dot v)^3. All three-block monomials vanish on this shell. Keep the 168 pure repeated, 168 pure distinct, 384 mixed repeated, and 1344 mixed distinct monomials; replace each of the 24 pure-cube plus linear terms by the two displayed unary centers. All coefficients are dyadic. The same feature supports occur on encoder and decoder sides because the factorization is symmetric and diagonal. Block and coordinate permutations preserve E8^3 and induce invertible binary label changes, so the seven full-support orbit checks establish all 2112 center widths.', + scope='Exact scalar fitting kernel and symmetric dyadic factorization with binary support bill. A finite recursive word, helper exits, scheduling, and a new kappa are not supplied by this certificate.') + + +def certify_e8_cubed(): + roots, fourth, ports, profiles = construct_shell() + _, packed, fitting = binary_labels(roots, ports) + values = {str(t): str(Fraction(t ** 3 - 4 * t, 48)) for t in range(-4, 5)} + require(values['4'] == '1' and all(values[str(t)] == '0' for t in (-2, 0, 2)), + 'Scalar kernel diagonal and even off-diagonal zeros') + return dict(status='PASS_EXACT_E8_CUBED_SCALAR_FACTORIZATION', + lattice='E8 cubed', doubled_coordinate_scale=2, norm_four_lines=89640, + norm_four_vectors=179280, e8_root_lines=120, e8_norm_four_lines=1080, + profile_counts={str(key): value for key, value in sorted(Counter(map(int, profiles)).items())}, + ports_sha256=hashlib.sha256(ports.astype('= 1, "only child contraction ratios >=1 are used") + shift = 0 + while x >= 2: + x /= 2 + shift += 1 + + def unit(y): + z = (y - 1) / (y + 1) + z2 = z * z + total = F(0) + power = z + for j in range(64): + total += 2 * power / (2 * j + 1) + power *= z2 + # Every omitted denominator is >=129, bounding the rest geometrically. + tail = 2 * power / (129 * (1 - z2)) + return total, total + tail + + low, high = unit(x) + low2, high2 = unit(F(2)) + return outward(low + shift * low2, high + shift * high2) + + +@lru_cache(None) +def power_interval(base, alpha): + ll, lu = log_interval(base) + low, high = alpha * ll, alpha * lu + require(0 <= low <= high < 1, "positive Taylor interval domain") + + def partial(x): + term = total = F(1) + for j in range(1, 33): + term *= x / j + total += term + return total, term + + lower, _ = partial(low) + upper, last = partial(high) + # Ratios after the first omitted term are bounded by high/34. + upper += (last * high / 33) / (1 - high / 34) + return outward(lower, upper) + + +def pressure(terms, m, alpha): + low = high = F(0) + for mass, rank in terms: + a, b = power_interval(F(m, rank), alpha) + low += mass * (a - 1) + high += mass * (b - 1) + return low, high + + +def partition(rank, cap): + if not rank: + return [] + count = (rank + cap - 1) // cap + quotient, remainder = divmod(rank, count) + return [quotient + (j < remainder) for j in range(count)] + + +def model(stages): + m = 16 * stages + 1 + cap = isqrt((m * m - 1) // 2) + base = [(F(2 * N * stages * 16), 16), + (F(stages * 17 * 256), 17), (F(stages * 15 * 560), 15)] + pairs = (stages - 1) // 2 + idle = [32 * (pairs - 1)] if pairs > 1 else [] + for j in range(1, pairs): + idle.extend([32 * j, 16]) + if pairs - j - 1 > 0: + idle.append(32 * (pairs - j - 1)) + idle_parts = [partition(rank, cap) for rank in idle] + for block in idle_parts: + base.extend((F(2 * N * rank), rank) for rank in block) + replication, pad = divmod(m, H) + helper = [(F(stages * rank), rank) for rank in (1, 7, 8, 1)] + helper.extend((F(stages * rank, replication), rank) + for rank in partition(pad, cap)) + stock = (stages - 1) * N + deficit = stock - stages * BILL + require(sum(mass for mass, _ in base) == m * stock - deficit, + "independent base rank-mass equality") + require(sum(mass for mass, _ in helper) == F(m * stages, replication), + "independent helper rank-mass equality") + require(all(0 < rank <= cap for _, rank in base + helper), + "every child has m^2>2r^2") + return dict(stages=stages, m=m, cap=cap, replication=replication, + pad=pad, stock=stock, deficit=deficit, base=base, + helper=helper, idle_slots=idle, idle_parts=idle_parts) + + +def boundary(row, target): + alpha = target / (1 - target) + bl, bu = pressure(row['base'], row['m'], alpha) + hl, hu = pressure(row['helper'], row['m'], alpha) + require(0 < hl <= hu, "strict positive helper pressure proves monotonicity") + low = (row['deficit'] - bu) / hu + high = (row['deficit'] - bl) / hl + count = floor_fraction(low) + require(count == floor_fraction(high), "certified integer helper boundary") + pass_slack = (row['deficit'] - bu - count * hu, + row['deficit'] - bl - count * hl) + fail_slack = (row['deficit'] - bu - (count + 1) * hu, + row['deficit'] - bl - (count + 1) * hl) + require(pass_slack[0] > 0 > fail_slack[1], "adjacent strict pass/fail") + # These controls enforce inclusion of padding and the correct hp profile. + no_pad = dict(row, helper=row['helper'][:4]) + wrong_hp = dict(row, helper=[(F(row['stages'] * H), H)] + row['helper'][4:]) + no_pad_count = alternate_count(no_pad, alpha) + wrong_hp_count = alternate_count(wrong_hp, alpha) + return dict(max_helpers=count, ports_per_helper=str(F(N, count)), + base_pressure_scaled_1e24=display_interval(bl, bu), + helper_pressure_scaled_1e24=display_interval(hl, hu), + threshold_real_interval_scaled_1e24=display_interval(low, high), + boundary_slack_scaled_1e24=display_interval(*pass_slack), + next_slack_scaled_1e24=display_interval(*fail_slack), + controls={'omitted_padding': {'mutated_max_helpers': no_pad_count, + 'detected': no_pad_count != count}, + 'unsplit_helper': {'mutated_max_helpers': wrong_hp_count, + 'detected': wrong_hp_count != count}}) + + +def alternate_count(row, alpha): + bl, bu = pressure(row['base'], row['m'], alpha) + hl, hu = pressure(row['helper'], row['m'], alpha) + low, high = (row['deficit'] - bu) / hu, (row['deficit'] - bl) / hl + require(floor_fraction(low) == floor_fraction(high), "control integer resolves") + return floor_fraction(low) + + +def load_predecessor(): + path = ROOT / 'research/h6-banked-breakeven/price_h6.py' + spec = importlib.util.spec_from_file_location('h6_source_comparison', path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def main(): + selected = json.loads((ROOT / 'certificates/selected-result.json').read_text()) + historical = json.loads((ROOT / 'certificates/checkpoints/frontier890.json').read_text()) + packet = json.loads((ROOT / 'research/community-efficient500-audit/packets/1424.json').read_text()) + proposed = re.search(r'\d+\.\d+', packet['title']).group(0) + targets = [('pr890_rounded', F('0.001661957775')), + ('pr890_checkpoint', F(historical['kappa'])), + ('pr1424_pending_title', F(proposed)), + ('current_selected', F(selected['kappa']))] + source = load_predecessor() + expected = {'pr890_rounded': [80558, 89683, 80753], + 'pr890_checkpoint': [80558, 89683, 80753], + 'pr1424_pending_title': [79617, 88409, 79399]} + results = [] + for name, target in targets: + rows = [] + for index, stages in enumerate((3, 5, 7)): + row = model(stages) + answer = boundary(row, target) + count = answer['max_helpers'] + if name in expected: + require(count == expected[name][index], "published boundary agrees") + require(all(item['detected'] for item in answer['controls'].values()), + "invoice mutation controls detected") + source_counts = {mode: source.breakeven(stages, target, mode) + for mode in ('exact', 'float')} + require(all(value == count for value in source_counts.values()), + "predecessor modes agree with independent pressure boundary") + endpoints = [source.kscaled(stages, count), source.kscaled(stages, count + 1)] + require(F(endpoints[0]) > target * 10**18 >= F(endpoints[1]), + "source lower-endpoint convention matches adjacent boundary") + # Each source certified interval is narrower than the target margins. + intervals = [source.b.invoice(N, H, {17: 256, 15: 560}, stages, + [16], [1, 7, 8, 1], r, False) + ['nominal_kappa_interval_scaled_1e18'] + for r in (count, count + 1)] + require(F(intervals[0][0]) > target * 10**18 > F(intervals[1][1]), + "both source root intervals lie strictly on the required side") + answer.update(stages=stages, m=row['m'], deficit=row['deficit'], + child_cap=row['cap'], stock_replication_factor=row['replication'], + helper_pad=row['pad'], idle_slots=row['idle_slots'], + idle_parts=row['idle_parts'], source_mode_counts=source_counts, + source_root_intervals_scaled_1e18=intervals, + boundary_stock=str(F(row['stock']) + F(stages * count, row['replication']))) + rows.append(answer) + results.append(dict(name=name, target=str(target), rows=rows)) + command = [sys.executable, '-B', str(ROOT / 'research/h6-banked-breakeven/price_h6.py')] + replay = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, check=True) + require(replay.stdout == (ROOT / 'research/h6-banked-breakeven/outputs/price_h6.txt').read_text(), + "source replay equals published price output") + costs = (ROOT / 'research/niemeier-lattices/COSTS.txt').read_text() + pauli = F(re.search(r'E8\^2 full Pauli factor\s+\d+\s+\d+\s+\d+\s+(\.\d+)', costs).group(1)) + e8 = F(re.search(r'E8 root reference\s+\d+\s+\d+\s+\d+\s+(\.\d+)', costs).group(1)) + costs_receipt = json.loads((ROOT / 'research/niemeier-lattices/evidence/COSTS.json').read_text()) + # These two rows are the inherited COSTS screens, with rank-max(r,h) idle + # relaxation. This does not replay the optimizer over all odd stages. + root_screen = dict(m=41, deficit=120, terms=[(F(9600), 8), (F(360), 9), + (F(3840), 16), (F(3840), 16), (F(1920), 9)]) + pauli_model = model(3) + screens = {'E8_root_reference': root_screen, + 'E8_squared_Pauli_factor': dict(m=49, deficit=23664, terms=pauli_model['base'])} + paper_intervals = {} + for name, row in screens.items(): + expected_mass = 41 * 480 - 120 if name == 'E8_root_reference' else 49 * 61920 - 23664 + require(sum(mass for mass, _ in row['terms']) == expected_mass, + "independent COSTS screen rank-mass equality") + case = next(item for item in costs_receipt['cases'] if item['name'] == name) + pair = case['fixed_center_widths']['kappa_interval_scaled_1e18'] + low, high = (F(value, 10**18) for value in pair) + lower_pressure = pressure(row['terms'], row['m'], low / (1 - low)) + upper_pressure = pressure(row['terms'], row['m'], high / (1 - high)) + require(lower_pressure[1] < row['deficit'] < upper_pressure[0], + "independent certification of fixed-stage COSTS root endpoints") + paper_intervals[name] = pair + ratio_low = F(paper_intervals['E8_squared_Pauli_factor'][0], + paper_intervals['E8_root_reference'][1]) + ratio_high = F(paper_intervals['E8_squared_Pauli_factor'][1], + paper_intervals['E8_root_reference'][0]) + root_banked = source.b.invoice(120, 9, {9: 8}, 5, [8], [9], 0, False) + names = ['research/h6-banked-breakeven/README.md', + 'research/h6-banked-breakeven/price_h6.py', + 'research/h6-banked-breakeven/outputs/price_h6.txt', + 'research/niemeier-lattices/workbench/paid-controller/banked.py', + 'research/niemeier-lattices/code/costs.py', + 'research/niemeier-lattices/COSTS.txt', + 'research/niemeier-lattices/evidence/COSTS.json', + 'research/niemeier-lattices/workbench/paid-controller/PAID-CONTROLLER.txt', + 'research/niemeier-lattices/workbench/helper-routes/compensation_rank.py', + 'certificates/selected-result.json', 'certificates/checkpoints/frontier890.json', + 'research/community-efficient500-audit/packets/1424.json', + 'docs/research/community-efficient500-review.md', selected['review'], + selected['source_manifest'], historical['review']] + pins = {name: hashlib.sha256((ROOT / name).read_bytes()).hexdigest() for name in names} + receipt = dict(status='PASS_INDEPENDENT_FIXED_INVOICE_BOUNDARIES', + no_new_kappa=True, source_commit='b496aed769dd724cd1ff6b921cade626562be27b', + source_hashes=pins, arithmetic=dict(log_terms=64, exp_degree=32, + outward_denominator=str(SCALE), displayed_interval_scale=str(DISPLAY)), + paper_ratio=str(pauli / e8), + paper_fixed_stage_intervals_scaled_1e18=paper_intervals, + paper_ratio_interval_scaled_1e24=display_interval(ratio_low, ratio_high), + paper_reference_banked_interval_scaled_1e18= + root_banked['nominal_kappa_interval_scaled_1e18'], + paper_ratio_scope='COSTS-screen ratio, not banked-invoice ratio: the L5 E8 reference has an idle rank8 relaxed to rank9 by COSTS.instance; banked.base charges its actual rank8. Only the fixed-stage root endpoints were independently recertified, not the inherited all-L optimality proof.', + selected_context={'review': selected['review'], 'source_manifest': selected['source_manifest'], + 'reproduce': selected['reproduce']}, + pr1424_context={'head': packet['head'], 'title': packet['title'], + 'admission': 'Pending parent PR1319 admission per efficient500 maintainer review'}, + source_output_replay='IDENTICAL', targets=results, + monotonicity='For every fixed alpha>0, P_base(alpha)+R*P_helper(alpha) is strictly increasing in R. Since all child bases exceed 1, pressure is strictly increasing in alpha. The adjacent strict signs therefore prove the globally largest admissible nonnegative integer R for this fixed invoice.', + scope='Only this nominal complex invoice, fixed data [16], helper [1,7,8,1], nonvirtual, and L=3,5,7. The selected record is compared numerically; its supplier is not repriced. PR1424 is a pinned pending title, not selected admission. No capacity lemma, scalar word, restoration chronology, bit supplier, outer transfer or construction theorem is proved.') + (HERE / 'RESULT.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(receipt['status']) + for item in results: + print(item['name'], [(r['stages'], r['max_helpers']) for r in item['rows']]) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/cyclic/frozen/mixed_rectangle.py b/research/h6-partial-frame-networks/cyclic/frozen/mixed_rectangle.py new file mode 100644 index 0000000000..73d430a02a --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/mixed_rectangle.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 +"""Actual four-port H6 mixed-source compensation: complete all-input word. + +The physical Clifford/adapter compiler is inherited, not executed here. +All ordinary frames, arbitrary dirt and both chronological orientations +are checked exactly. This is a bounded construction, not a full H6 supplier. +""" +from fractions import Fraction as F +from itertools import combinations, product +from pathlib import Path +from collections import Counter +import hashlib +import json +import copy + +HERE = Path(__file__).resolve().parent +H = 17 +FULL = tuple(1 << i for i in reversed(range(H))) + + +def need(ok, label): + if not ok: raise ValueError(label) + + +def basis(words): + piv = {} + for v in words: + for k in sorted(piv, reverse=True): + if v >> k & 1: v ^= piv[k] + if v: + k = v.bit_length()-1 + for j in list(piv): + if piv[j] >> k & 1: piv[j] ^= v + piv[k] = v + return tuple(piv[k] for k in sorted(piv, reverse=True)) + + +def included(a,b): return len(basis(a+b)) == len(b) + + +def perp(v): + k = (v & -v).bit_length()-1 + return basis((1 << i) ^ ((1 << k) if v >> i & 1 else 0) for i in range(H) if i != k) + + +def mm(a,b): + return [xor(b[j] for j in range(len(b)) if row >> j & 1) for row in a] + + +def xor(xs): + z = 0 + for x in xs: z ^= x + return z + + +def tr(a,n): return [sum(((row >> j) & 1) << i for i,row in enumerate(a)) for j in range(n)] + + +def inv(a): + n = len(a); work = [row | (1 << (n+i)) for i,row in enumerate(a)] + for j in range(n): + p = next(i for i in range(j,n) if work[i] >> j & 1) + work[j],work[p] = work[p],work[j] + for i in range(n): + if i != j and work[i] >> j & 1: work[i] ^= work[j] + need([r & ((1<> n for r in work] + + +def cong(t,m): return mm(mm(t,m),tr(t,len(t))) + + +def symp(m): + n = len(m); t = [1<> b & 1) + for cur,dst in ((a,k),(b if b != k else a,k+1)): + t[cur],t[dst] = t[dst],t[cur] + work = cong(t,m) + for i in range(k+2,n): + left,right = (work[i] >> (k+1)) & 1,(work[i] >> k) & 1 + if left: t[i] ^= t[k] + if right: t[i] ^= t[k+1] + work = cong(t,m) + need(work == [1 << (i^1) for i in range(n)], "symplectic congruence") + return t + + +def canonical_roots(): + roots = [] + for i,j in combinations(range(8),2): + for x,y in product((-2,2),repeat=2): + a = [0]*8; a[i],a[j] = x,y; roots.append(tuple(a)) + roots.extend(a for a in product((-1,1),repeat=8) if sum(a) % 4 == 0) + return sorted({a if next(x for x in a if x) > 0 else tuple(-x for x in a) for a in roots}) + + +def dot(a,b): + z = sum(x*y for x,y in zip(a,b)) + need(z % 4 == 0, "integral E8 pairing") + return z//4 + + +def actual_labels(ports): + # Source-faithful bit implementation of e8_cubed.py::binary_labels. + roots = canonical_roots() + gram = [sum((dot(a,b)&1)<> b & 1 for a in av for b in av): + a,b = next((a,b) for a in av for b in av if work[a] >> b & 1) + sel.extend((a,b)); left,right = work[a],work[b] + work = [r ^ (right if left >> i & 1 else 0) ^ (left if right >> i & 1 else 0) for i,r in enumerate(work)] + av.remove(a); av.remove(b) + need(len(sel) == 8, "binary E8 basis size") + qq = [roots[i] for i in sel] + small = [sum(((gram[i]>>j)&1)<> c & 1 for a in available for c in available): + a,c = next((a,c) for a in available for c in available if work[a] >> c & 1) + selected.extend((a,c)) + left, right = work[a], work[c] + work = [row ^ (right if left >> i & 1 else 0) + ^ (left if right >> i & 1 else 0) + for i,row in enumerate(work)] + available.remove(a) + available.remove(c) + small = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in selected] + inverse = m.inv(small) + form = inverse+[row << 8 for row in inverse] + even = [((1 << 16)-1) ^ (1 << i) for i in range(16)] + change = m.mm(m.inv(m.symp(form)), m.symp(even)) + need(m.cong(change, even) == form, 'pinned standard-dot isometry') + mapping = m.mm(change, [(1 << i)|(1 << 16) for i in range(16)]) + coordinates = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in range(120)] + return [[((1 << 17)-1) ^ m.mm([x|(y << 8)], mapping)[0] + for y in coordinates] for x in coordinates] + + +def orthogonal_involution(roots): + position = {a:i for i,a in enumerate(roots)} + mates = [] + for a in roots: + c = list(a) + if all(x % 2 == 0 for x in a): + nonzero = [i for i,x in enumerate(a) if x] + c[nonzero[1]] *= -1 + else: + for i in range(4,8): + c[i] *= -1 + mates.append(position[tuple(c)]) + need(all(i != j and mates[j] == i and m.dot(roots[i], roots[j]) == 0 + for i,j in enumerate(mates)), 'explicit120-root orthogonal involution') + pairs = [(i,j) for i,j in enumerate(mates) if i < j] + need(len(pairs) == 60, 'sixty orthogonal b-pairs') + return pairs + + +def tiling(): + roots = m.canonical_roots() + need(sorted(i for row in TRIPLES for i in row) == list(range(120)), + 'explicit disjoint acute-triple partition') + signs = [] + for row in TRIPLES: + sigma = [1]+[m.dot(roots[row[0]], roots[i]) for i in row[1:]] + need(all(abs(x) == 1 for x in sigma), 'triple gauge signs') + need(all(sigma[i]*sigma[j]*m.dot(roots[row[i]], roots[row[j]]) == 1 + for i in range(3) for j in range(i)), 'acute triple after gauge') + signs.append(sigma) + pairs = orthogonal_involution(roots) + packed = packed_root_pairs(roots) + assigned = set() + examples = [] + coefficient_census = Counter() + for ti, aa in enumerate(TRIPLES): + sigma = signs[ti] + for bi, bb in enumerate(pairs): + labels = [packed[a][bb[z]] for a in aa for z in range(2)] + planes = [m.basis(labels[2*g:2*g+2]) for g in range(3)] + arcs = [m.basis(planes[g]+planes[(g+1)%3]) for g in range(3)] + need(all(len(x) == 2 for x in planes) and all(len(x) == 3 for x in arcs), + 'actual r3 module source and final reader frames') + need(all(m.included(arcs[g], m.perp(labels[2*((g-1)%3)+z])) + for g in range(3) for z in range(2)), 'actual module final target caps') + need(all(m.included(planes[j], arcs[(j-1)%3]) for j in range(3)), + 'actual mutable source nested visits') + if ti == 0 and bi < 2: + examples.append({'triple': ti, 'b_pair': bi, 'labels': labels, + 'planes': [list(x) for x in planes], + 'final_arcs': [list(x) for x in arcs]}) + for epsilon in (-1,1): + ports = [] + indices = [] + for group,a in enumerate(aa): + sign = epsilon*sigma[group] + for bj in bb: + ports.append(roots[a]+tuple(sign*x for x in roots[bj])) + indices.append(2160+240*a+2*bj+int(sign < 0)) + need(not (assigned & set(indices)), 'disjoint module source/target IDs') + assigned.update(indices) + for i in range(6): + for j in range(6): + t = m.dot(ports[i], ports[j]) + cij = F(int(i == j))-F(t**3-4*t,48) + expected = F(0) if i//2 == j//2 else F( + sigma[i//2]*sigma[j//2]*(-5 if i%2 == j%2 else 1),16) + need(cij == expected, 'literal actual coefficient equals gauged cyclic module') + need((labels[i]&labels[j]).bit_count()%2 == (1+t)%2, + 'literal actual source address parity') + if cij: + coefficient_census[abs(cij)] += 1 + need(assigned == set(range(2160,30960)), 'all28800 root-product ports tiled exactly once') + need(coefficient_census == {F(1,16):57600, F(5,16):57600}, + 'exact115200 compensated ordered pairs') + return roots, pairs, signs, examples, coefficient_census + + +def actual_edge_completion_model(L, residual_edges): + row = b.model(L, [16], [16], [17], 0) + census = Counter(row['H']) + # Replace residual16 source/target paths only for the28800 tiled ports. + for path in ([1,1,14], [3,13]): + census[16] -= L*28800 + for rank in path: + census[rank] += L*28800 + for count,path in ((28800,[2,1,14]), (residual_edges,[1,15,1])): + for rank in path: + census[rank] += L*count + roles = 28800+residual_edges + if row['pad']: + for rank in b.oracle.partition(row['pad'], row['cap']): + census[rank] += F(L*roles, row['q']) + row.update(H=census, W=row['W']+F(L*roles,row['q']), R=roles) + need(sum(rank*n for rank,n in census.items()) == row['m']*row['W']-row['D'], + 'complete tiled-plus-edge full H6 histogram') + return row + + +def main(): + roots, pairs, signs, examples, coefficient_census = tiling() + path = 'research/h6-independent-audit/walsh/results.json' + raw = subprocess.check_output(['git','show',b.PIN+':'+path],cwd=b.REPO) + inherited = json.loads(raw) + need(inherited['compensation_nonzeros'] == 480337920 + and inherited['exceptional_abs_t_3_pairs'] == 3363840, + 'pinned all-pair support receipt') + residual_exceptional = 3363840-57600 + residual_unit = 480337920-3363840-57600 + residual = residual_exceptional+residual_unit + need(residual == 480222720, 'exact residual ordered support count') + # An actual complete local word exists by using initial-line residual + # edge readers and delivering them at final caps after module delivery. + component_comp = 4800*396+24*residual_unit+30*residual_exceptional + forward = 247217040+component_comp + dual = 247219488+component_comp + old = 247217040+24*(480337920-3363840)+30*3363840 + need(old-forward == 1209600, 'actual component primitive saving') + row = actual_edge_completion_model(5,residual) + price = b.target_row(row,F('.002')) + need(price['verdict'].startswith('FAILS'), 'complete edge completion fails target') + # C-D=(I-D)-K. Every actual r3 K block is invertible; pure2160 I + # gives rank(I-D)=30960. Hence rank residual >=30960-816. + private_floor = 30960-816 + need(13872+private_floor > 30960, 'actual module private residual coverage fails all L') + # Even if each module's coefficients are redesigned arbitrarily, keeping + # zero own-group2x2 blocks forces rank(I-D_module)>=2. The most favorable + # disjoint-module rank floor is2*4800+2160=11760, residual>=10944. + redesigned_A = 2*4800+2160 + redesigned_residual = redesigned_A-816 + need(redesigned_residual == 10944, 'redesigned disjoint-module residual rank floor') + # Grant free residual banks and ideal rank1 private descents. Active data + # pressure alone/NL >32*.002*log L. Its excess against D is bounded by + # min_(L>0) [.064 log L+1/L] -(1-(13872+10944)/30960). + constant = F(8,125) + tail = constant*(1+b.oracle.log_interval(1/constant)[0])-(1-F(13872+10944,30960)) + need(tail > 0, 'all positive L redesigned private residual fails .002') + out = {'status':'PASS_ACTUAL_FULL_ROOT_PRODUCT_DYNAMIC_TILING_AND_PAID_RESIDUAL_NO_NEW_KAPPA', + 'source_pin':b.PIN,'inherited_support_source':path, + 'inherited_support_sha256':hashlib.sha256(raw).hexdigest(), + 'canonical_roots':roots,'a_triples':TRIPLES,'triple_gauge_signs':signs, + 'b_orthogonal_involution_pairs':pairs,'module_count':4800, + 'module_rule':'For each acute a-triple, orthogonal b-pair, epsilon=+-1, port(group,z)=(a_group,epsilon*sigma_group*b_z). Source product ID2160+240*a+2*b+int(sign<0).', + 'actual_tiled_ports':28800,'untiled_ports':{'indices':[0,2159], 'meaning':'Both1080-port pure norm4 blocks; complete interval0<=i<2160.'}, + 'actual_module_frame_cases':2400,'frame_examples':examples, + 'covered_ordered_nonzero_entries':115200, + 'covered_unit_entries':57600,'covered_exceptional_entries':57600, + 'uncovered_ordered_nonzero_entries':residual, + 'uncovered_unit_entries':residual_unit, + 'uncovered_exceptional_entries':residual_exceptional, + 'exact_uncovered_set':'All ordered pairs(t,s) with actual odd Gram t_ts and with t,s not belonging to the same six-port module above. Every pair involving a pure port is outside the modules; within-module C equals D exactly.', + 'actual_full_completion':{'module_readers':28800,'residual_edge_readers':residual, + 'ordinary_K_centres':816,'K_private_C':13872, + 'total_ordinary_compensation_roles':28800+residual, + 'component_primitives_forward':forward, + 'component_primitives_dual':dual, + 'component_saving_against_full_edge_word':old-forward, + 'L5_stock_W':str(row['W']),'L5_q_replica_banks':5*(row['R']+816), + 'L5_complete_histogram':{r:str(n) for r,n in sorted(row['H'].items())}, + 'L5_target_002':price, + 'word_contract':'AtZERO precompensate K,module and residual dirt. Load every residual edge helper at its original source line before module source climbs. Execute changing module gathers on disjoint nested arcs; sources reachFULL. Run unchanged816-centre K while targetsZERO. Deliver modules at their rank3 arcs, then targets finish caps. Deliver each residual edge helper at its rank16 target cap. Restore all compensation helpers atFULL. Same-order dual has separate K private episodes. Full billion-event stream is mathematically specified/counted, not materialized.'}, + 'actual_private_residual':{'rank_I_minus_D':30960,'rank_lower':private_floor, + 'best_private_rank_floor':private_floor, + 'total_private_C_lower':13872+private_floor, + 'all_L_coverage_deficit_upper':'-30960-13056*L'}, + 'redesigned_disjoint_r3_private_residual':{'rank_I_minus_D_lower':redesigned_A, + 'rank_residual_lower':redesigned_residual, + 'total_private_C_lower':13872+redesigned_residual, + 'all_positive_L_active_data_gap_lower':str(tail), + 'assumptions':'Arbitrary weights per disjoint6-port r3 module, no within-own-group coefficient, D=0 on pure ports. All residual dependence returns through private episodes, each granted ideal rank1 and free ordinary banks.'}, + 'controls':{'tile_signs_required':any(x<0 for row in signs for x in row), + 'b_mates_are_distinct':all(i!=j for i,j in pairs), + 'pure_ports_not_claimed_tiled':len(roots)*240 == 28800, + 'dropping_residual_changes_operator':residual>0}, + 'scope':'Actual disjoint r3 tiling with exact residual set, actual edge-helper completion and scoped private-residual failures. Overlapping/composed dynamic modules, mutable residual networks, changed source/target schedules and different centre interfaces remain open. No new kappa or full physical/approximate supplier admission.'} + (HERE/'MODULE-TILING-RESULT.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']+' modules=4800 root_ports=28800 pure_ports=2160 residual_edges='+str(residual)) + print('actual private residual rank>=',private_floor,'Ctotal>=',13872+private_floor) + print('redesigned private residual rank>=',redesigned_residual,'active gap lower',b.dec(tail)) + print('full edge completion primitives',forward,dual,'L5 M',price['normalized_moment']['lo']) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/cyclic/frozen/optimistic_budget.py b/research/h6-partial-frame-networks/cyclic/frozen/optimistic_budget.py new file mode 100644 index 0000000000..9ca73c36f5 --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/optimistic_budget.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Complete optimistic H6 mixed-channel rank/stock/moment screens. + +Pinned exact positive-series oracle, actual m=1+16L, full816 ordinary K +centres plus816 width17 private K copies, actual idle parts and helper pads. +No constructed full H6 supplier or kappa is inferred from a passing screen. +""" +from collections import Counter +from decimal import Decimal, localcontext +from fractions import Fraction as F +from math import isqrt +from pathlib import Path +import hashlib, json, subprocess, types + +HERE = Path(__file__).resolve().parent +REPO = Path('/Users/ross/git/math/integer-mult-bounds') +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +N,H,KC,KBILL = 30960,17,816,13872 +ORACLE = 'research/h6-independent-audit/invoice/verify.py' +raw = subprocess.check_output(['git','show',PIN+':'+ORACLE],cwd=REPO) +oracle = types.ModuleType('pinned_h6_oracle'); oracle.__file__ = str(REPO/ORACLE) +exec(compile(raw,oracle.__file__,'exec'),oracle.__dict__) +need = oracle.require +SOURCE_HASHES = {ORACLE:hashlib.sha256(raw).hexdigest()} +for rel in ('research/h6-compensation-network/k_encoder/RESULT.json', + 'research/h6-compensation-network/pricing/verify.py'): + content = subprocess.check_output(['git','show',PIN+':'+rel],cwd=REPO) + SOURCE_HASHES[rel] = hashlib.sha256(content).hexdigest() + if rel.endswith('RESULT.json'): + kr = json.loads(content) + need(kr['K_ordinary_roles'] == KC and kr['private_descent_C'] == KBILL, 'actual full K inventory') + + +def dec(x): + with localcontext() as c: + c.prec = 24 + return str(Decimal(x.numerator)/Decimal(x.denominator)) + + +def interval(a,b): return {'lower':str(a),'upper':str(b),'lo':dec(a),'hi':dec(b)} + + +def model(L,source,target,helper,R): + need(L >= 3 and L%2 == 1, 'odd stages at least3') + need(sum(source) == sum(target) == 16 and sum(helper) == 17, 'whole residual paths') + m = 1+16*L; q,p = divmod(m,H); cap = isqrt((m*m-1)//2) + census = Counter() + def add(path,count): + for r in path: + if r: census[r] += count + add(source,L*N); add(target,L*N) + add([17],L*KC) # K private descents; NOT its ordinary centres + inherited = oracle.model(L) + for block in inherited['idle_parts']: add(block,2*N) + # Ordinary K centres and compensation roles have disjoint paid banks. + add([17],L*KC); add(helper,L*R) + if p: add(oracle.partition(p,cap),F(L*(KC+R),q)) + W = F((L-1)*N)+F(L*(KC+R),q) + D = (L-1)*N-L*KBILL + need(sum(r*n for r,n in census.items()) == m*W-D, 'complete paid rank mass') + need(all(m*m > 2*r*r for r in census), 'strict native child cap') + need(all((q*n).denominator == 1 for n in census.values()), 'integral q-replica profile') + return {'L':L,'m':m,'q':q,'pad':p,'cap':cap,'H':census,'W':W,'D':D, + 'source':source,'target':target,'helper':helper,'R':R, + 'idle':inherited['idle_slots'],'idle_parts':inherited['idle_parts']} + + +def pressure(row,b): + terms = [(n*r,r) for r,n in row['H'].items()] + return oracle.pressure(terms,row['m'],b) + + +def target_row(row,k): + b = k+F(1,10**24) + lo,hi = pressure(row,b) + sl,su = row['D']-hi,row['D']-lo + return {'target':str(k),'exponent_b':str(b),'pressure':interval(lo,hi), + 'raw_slack':interval(sl,su), + 'normalized_moment':interval(1-sl/(row['m']*row['W']),1-su/(row['m']*row['W'])) + if False else interval(1+(lo-row['D'])/(row['m']*row['W']),1+(hi-row['D'])/(row['m']*row['W'])), + 'verdict':'PASSES_OPTIMISTIC_RANK_SCREEN_ONLY' if sl>0 else 'FAILS_OPTIMISTIC_RANK_SCREEN' if su<0 else 'UNRESOLVED'} + + +def helper_boundary(row,k): + base = model(row['L'],row['source'],row['target'],row['helper'],0) + one = model(row['L'],row['source'],row['target'],row['helper'],1) + unit = Counter(one['H']); unit.subtract(base['H']); need(all(n>=0 for n in unit.values()), 'positive helper bill') + b = k+F(1,10**24) + bl,bu = pressure(base,b) + ul,uu = oracle.pressure([(n*r,r) for r,n in unit.items() if n],row['m'],b) + need(ul>0,'strict helper monotonicity') + low,high = (row['D']-bu)/uu,(row['D']-bl)/ul + count = low.__floor__() + need(count == high.__floor__(),'exact adjacent integer helper boundary') + if count < 0: + need(row['D']-bl < 0,'even zero helpers fails') + return {'largest_nonnegative_R':None,'zero_helper_verdict':'FAILS','real_threshold':interval(low,high)} + pass_slack = row['D']-bu-count*uu,row['D']-bl-count*ul + fail_slack = row['D']-bu-(count+1)*uu,row['D']-bl-(count+1)*ul + need(pass_slack[0]>0>fail_slack[1],'adjacent strict helper signs') + return {'largest_nonnegative_R':count,'R_over_N':str(F(count,N)), + 'real_threshold':interval(low,high),'pass_slack':interval(*pass_slack),'next_slack':interval(*fail_slack)} + + +def main(): + configs = [('single_plane_u2',[1,15],[2,14],[2,15]), + ('single_plane_u4',[3,13],[4,12],[4,13]), + ('single_plane_u8',[7,9],[8,8],[8,9]), + ('single_plane_u16',[15,1],[16],[16,1]), + ('cyclic_three_group_two_levels',[1,15],[2,1,13],[2,1,14]), + ('cyclic_seven_group_six_levels',[1,15],[2,1,1,1,1,1,9],[2,1,1,1,1,1,10])] + targets = list(map(F,('0.002','0.003','0.005'))) + rows = [] + for name,s,t,h in configs: + for L in range(3,34,2): + r = model(L,s,t,h,N) + rows.append({'name':name,'stages':L,'m':r['m'],'q':r['q'],'pad':r['pad'], + 'child_cap':r['cap'],'source_path':s,'target_path':t,'helper_path':h, + 'compensation_R':N,'ordinary_K_roles':KC,'K_private_rank':KBILL, + 'stock_W':str(r['W']),'coverage_deficit':r['D'], + 'complete_rank_mass':str(sum(rank*n for rank,n in r['H'].items())), + 'rank_histogram':{rank:str(n) for rank,n in sorted(r['H'].items())}, + 'q_replica_stock':str(r['q']*r['W']), + 'q_replica_helper_banks':L*(N+KC), + 'q_replica_helper_pad_rank':L*(N+KC)*r['pad'], + 'idle_slots':r['idle'],'idle_parts':r['idle_parts'], + 'targets':[dict(target_row(r,k),helper_boundary=helper_boundary(r,k)) for k in targets]}) + # A cheap all-L tail for the .005 screen, even before helpers/centres. + # Active data mass is32NL and every split rank<=16. Thus pressure/(NL) + # >=32*b*log(m/16)>32*b*log L; D/(NL)<1-KBILL/N. + log33 = oracle.log_interval(F(33))[0] + tailgap = 32*(F('0.005')+F(1,10**24))*log33-(1-F(KBILL,N)) + need(tailgap>0,'all odd L>=33 fail .005 from active data alone') + need(all(x['targets'][2]['verdict'].startswith('FAILS') for x in rows if x['stages']<33), 'all scanned L<=31 fail .005 with R=N') + # Defect controls change a material whole histogram / arity assumption. + control = model(5,[1,15],[2,1,13],[2,1,14],N) + before = pressure(control,F('0.003')) + bad = dict(control,H=Counter(control['H'])); bad['H'][13]-=F(5*(N+KC),4) + need(pressure(bad,F('0.003')) != before,'omitted helper padding detected') + badm = dict(control,m=86) + need(pressure(badm,F('0.003')) != before,'wrong m86 detected') + badk = dict(control,H=Counter(control['H'])); badk['H'][17]-=5*KC + need(pressure(badk,F('0.003')) != before,'omitted ordinary K centres detected') + badc = dict(control,H=Counter(control['H'])); badc['H'][17]-=5*KC + need(sum(rank*n for rank,n in badc['H'].items()) != control['m']*control['W']-control['D'], 'omitted K private copies break coverage') + out = {'status':'PASS_COMPLETE_OPTIMISTIC_H6_MIXED_BUDGET_NO_NEW_KAPPA','source_pin':PIN, + 'source_hashes':SOURCE_HASHES,'modern_exponent_convention':'b=k+1e-24; both complete suppliers and all changed-arity/native/physical/analytic interfaces still required.', + 'N':N,'h':H,'K_center_count':KC,'K_private_C':KBILL, + 'rows':rows,'all_L_005_tail_gap_lower':str(tailgap),'negative_controls':4, + 'scope':'Full leading rank/stock moment for declared favorable profiles. No full-domain decomposition, geometry, common labels, approximate-child precision, bank/controller/tape, BIT or outer supplier admitted. Single-plane profiles cannot realize connected full C under the one-visit static-rectangle contract.'} + (HERE/'OPTIMISTIC-BUDGET-RESULT.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']+' rows='+str(len(rows))+' targets=3 controls=4') + for name,_,_,_ in configs: + for k in map(str,targets): + candidates=[x for x in rows if x['name']==name] + best=max(candidates,key=lambda x:F(next(y for y in x['targets'] if y['target']==k)['raw_slack']['lower'])) + z=next(y for y in best['targets'] if y['target']==k) + print(name,'target',k,'bestL',best['stages'],'M',z['normalized_moment']['lo'],'maxR',z['helper_boundary']['largest_nonnegative_R']) + + +if __name__ == '__main__':main() diff --git a/research/h6-partial-frame-networks/cyclic/frozen/pricing.py b/research/h6-partial-frame-networks/cyclic/frozen/pricing.py new file mode 100644 index 0000000000..f9434ab83e --- /dev/null +++ b/research/h6-partial-frame-networks/cyclic/frozen/pricing.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +"""Exact nominal invoices for the conditional H6 compensation network. + +The independent rational-series oracle from h6-independent-audit is reused; +the predecessor banked module only nominates root intervals for a separately +checked invoice. No partial block is normalized to a full-port saving. +""" +import hashlib +import importlib.util +import json +import re +import sys +from collections import Counter +from fractions import Fraction as F +from pathlib import Path + +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parents[3] +HERE = Path(__file__).resolve().parent +PACKAGE = HERE.parent +sys.path.insert(0, str(PACKAGE)) +from artifact import load_receipt + + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +oracle = load('h6_independent_invoice_oracle', ROOT / 'research/h6-independent-audit/invoice/verify.py') +sys.path.insert(0, str(ROOT / 'research/niemeier-lattices/workbench/paid-controller')) +import banked +require = oracle.require +N, H, R, R3 = 30960, 17, 480337920, 3363840 +DISPLAY = 10**24 + + +def scaled(low, high): + return oracle.display_interval(low, high) + + +def helper_terms(stages, path, count): + m = 16 * stages + 1 + q, pad = divmod(m, H) + require(sum(path) == H, 'ordinary helper path spans17') + terms = [(F(count * stages * rank), rank) for rank in path] + if pad: + terms.append((F(count * stages * pad, q), pad)) + require(sum(mass for mass, _ in terms) == F(count * stages * m, q), + 'complete helper mass including pads') + return terms, q, pad + + +def full_invoice(stages, histogram, compensation_helpers=R): + original = oracle.model(stages) + centers = sum(width * count for width, count in histogram.items()) + terms = [(F(2 * N * stages * 16), 16)] + terms.extend((F(stages * width * count), width) for width, count in histogram.items()) + for block in original['idle_parts']: + terms.extend((F(2 * N * rank), rank) for rank in block) + stock = F((stages - 1) * N) + deficit = stock - stages * centers + require(sum(mass for mass, _ in terms) == original['m'] * stock - deficit, + 'independent full base identity') + for count, path in ((compensation_helpers, [1, 15, 1]), (816, [17])): + add, q, pad = helper_terms(stages, path, count) + terms.extend(add) + stock += F(stages * count, q) + require(sum(mass for mass, _ in terms) == original['m'] * stock - deficit, + 'independent complete invoice identity') + require(all(original['m']**2 > 2 * rank**2 for _, rank in terms), + 'strict child cap on every actual/pad child') + return dict(stages=stages, m=original['m'], cap=original['cap'], q=q, pad=pad, + terms=terms, stock=stock, deficit=deficit, center_bill=centers, + idle_slots=original['idle_slots'], compensation_helpers=compensation_helpers) + + +def comparison(row, target): + low, high = oracle.pressure(row['terms'], row['m'], target / (1 - target)) + slack = row['deficit'] - high, row['deficit'] - low + require(slack[1] < 0, 'full edge invoice strictly fails requested target') + return dict(target=str(target), pressure_scaled_1e24=scaled(low, high), + slack_scaled_1e24=scaled(*slack), verdict='STRICTLY_FAILS_NOMINAL_SCREEN') + + +def edge_budget(row, target): + """Reprice the edge allowance using its actual [1,15,1] helper path.""" + unit, _, _ = helper_terms(row['stages'], [1,15,1], 1) + by_rank = Counter() + for mass, rank in row['terms']: + by_rank[rank] += mass + for mass, rank in unit: + by_rank[rank] -= row['compensation_helpers'] * mass + require(all(value >= 0 for value in by_rank.values()), 'removed only edge helper work') + base = [(mass, rank) for rank, mass in by_rank.items() if mass] + alpha = target/(1-target) + bl, bu = oracle.pressure(base, row['m'], alpha) + hl, hu = oracle.pressure(unit, row['m'], alpha) + low, high = (row['deficit']-bu)/hu, (row['deficit']-bl)/hl + count = oracle.floor_fraction(low) + require(count == oracle.floor_fraction(high), 'exact edge helper allowance resolves') + pass_slack = row['deficit']-bu-count*hu, row['deficit']-bl-count*hl + fail_slack = row['deficit']-bu-(count+1)*hu, row['deficit']-bl-(count+1)*hl + require(pass_slack[0] > 0 > fail_slack[1], 'edge allowance adjacent signs') + return dict(max_edge_helpers=count, boundary_slack_scaled_1e24=scaled(*pass_slack), + next_slack_scaled_1e24=scaled(*fail_slack), + scope='Actual [1,15,1] edge path with the same base and816 K helpers; not the earlier H6 [1,7,8,1] budget.') + + +def nominal_root(row): + # Nomination and source certification are differential checks, not the oracle. + source = dict(m=row['m'], terms=[(mass, F(row['m'], rank)) + for mass, rank in row['terms']], + stock=row['stock'], deficit=row['deficit']) + a, b = banked.c.bracket(source) + pair = banked.c.scaled(a / (1 + a), b / (1 + b)) + lo, hi = (F(value, 10**18) for value in pair) + pl = oracle.pressure(row['terms'], row['m'], lo / (1 - lo)) + ph = oracle.pressure(row['terms'], row['m'], hi / (1 - hi)) + require(pl[1] < row['deficit'] < ph[0], 'independent nominal-root enclosure') + return pair + + +def partial_profile(path): + result = load_receipt(path) + proof_descriptor = json.loads(path.read_text()).get('proof_data') + require(result.get('full_forward_and_same_order_dual_checks') is True, + 'partial route must have both arbitrary-dirt orientations') + profiles = [] + for role, key in (('sources', 'source_paths'), ('targets', 'target_paths'), ('helpers', 'helper_paths')): + entries = result[key] + if isinstance(entries, dict): + entries = [entries] + profiles.extend((role, entry['count'], entry['path']) for entry in entries) + mass = sum(count * sum(profile) for _, count, profile in profiles) + require(mass == result['total_local_transition_rank'], 'partial actual emitted path mass') + out = [] + for stages in (3, 5, 7): + m = 16 * stages + 1 + terms = [] + for _, count, profile in profiles: + terms.extend((F(stages * count * rank), rank) for rank in profile) + helpers = sum(count for role, count, _ in profiles if role == 'helpers') + for role, count, profile in profiles: + if role == 'helpers': + helper_terms(stages, profile, count) + q, pad = divmod(m, H) + terms.append((F(stages * helpers * pad, q), pad)) + require(all(m*m > 2 * rank*rank for _, rank in terms), 'partial strict child caps') + helper_stock = F(stages * helpers, q) + ordinary_mass = stages * mass + pad_mass = F(stages * helpers * pad, q) + out.append(dict(stages=stages, m=m, ordinary_transition_rank_mass=ordinary_mass, + pad_rank_mass=str(pad_mass), helper_stock=str(helper_stock), + replication=q, physical_helper_banks_per_stage=helpers, + replicated_pad_rank_mass=stages * helpers * pad, + target_pressure_scaled_1e24={name: scaled(*oracle.pressure(terms, m, target/(1-target))) + for name, target in targets.items()})) + return dict(path=str(path.relative_to(ROOT)), sha256=hashlib.sha256(path.read_bytes()).hexdigest(), + proof_data_descriptor=proof_descriptor, + status=result['status'], role_profiles=[dict(role=role, count=count, path=profile) + for role, count, profile in profiles], + local_transition_rank_mass=mass, helper_count=result['helper_count'], invoices=out, + scope='Partial standalone compensation only: actual register-path and helper-bank contributions at the specified full-template m. No complete data/controller stock, deficit, K composition or full-port nominal root is inferred. Source-set size is not used as N in an overall saving.') + + +selected = json.loads((ROOT / 'certificates/selected-result.json').read_text()) +packet = json.loads((ROOT / 'research/community-efficient500-audit/packets/1424.json').read_text()) +targets = {'selected': F(selected['kappa']), + 'pr1424_pending': F(re.search(r'\d+\.\d+', packet['title']).group(0))} + + +def main(): + k_path = PACKAGE / 'k_encoder/RESULT.json' + k_word = json.loads(k_path.read_text()) + require(k_word['status'] == 'PASS_EXPLICIT_K_WORD_AND_COMPOSED_FIXTURES' and + k_word['K_ordinary_roles'] == 816 and k_word['ordinary_center_path'] == [17] and + k_word['private_descent_C'] == 13872, 'explicit K word supplies the billed profile') + def primitive(coefficient): + value = abs(F(coefficient)) + return 3+(value.numerator.bit_length()-1)+value.numerator.bit_count()+(value.denominator.bit_length()-1) + gather_cost = sum(count*primitive(value) for value,count in k_word['gather_coefficients'].items()) + scatter_cost = sum(count*primitive(value) for value,count in k_word['scatter_coefficients'].items()) + require(sum(k_word['gather_coefficients'].values()) == k_word['feature_nonzeros'] == + sum(k_word['scatter_coefficients'].values()), 'complete K nonzero coefficient counts') + # Clear/copy/erase contributes3 per private episode; the dual replacement + # prices the copy as a unit add (4), raising its episode charge to6. + k_forward = 2*(gather_cost+scatter_cost)+3*816 + k_dual = 2*(gather_cost+scatter_cost)+6*816 + require(k_forward == k_word['K_forward_primitive_bound'] and + k_dual == k_word['K_dual_primitive_bound'] == 247219488, + 'independent K weighted-primitive recount in both orientations') + k_bound = max(k_forward,k_dual) + bucket_path = PACKAGE / 'routes/FULL-MASK-SCREEN.json' + bucket = load_receipt(bucket_path) + lanes = bucket['required_distinct_ordinary_helper_lanes'] + require(lanes == 227312640 and bucket['every_target_mask_span_dimension'] == 16, + 'full bucket compensation lane inventory') + models = [] + for name, hist, compensation_helpers in ( + ('fullwidth_K_conditional_profile', {17: 816}, R), + ('heterogeneous_K_conditional_alternative', {17: 256, 15: 560}, R), + ('bucketed_fullwidth_K_conditional_profile', {17: 816}, lanes)): + rows = [] + for stages in (3, 5, 7): + row = full_invoice(stages, hist, compensation_helpers) + pair = nominal_root(row) + require(F(pair[1], 10**18) < targets['selected'], 'nominal root below selected') + # T=q supplies an exactly integral bank arrangement, separately for + # the edge helper group and the K-center helper group. + replication = row['q'] + banks_per_stage = replication * (compensation_helpers + 816) // row['q'] + require(replication * (compensation_helpers + 816) % row['q'] == 0, + 'integral replicated helper banks') + require((replication * row['stock']).denominator == 1, 'integral replicated complete stock') + rows.append(dict(stages=stages, m=row['m'], center_private_copy_bill=row['center_bill'], + deficit=str(row['deficit']), stock_per_template=str(row['stock']), + replication=replication, replicated_stock=str(replication * row['stock']), + stock_replication_factor=row['q'], helper_pad=row['pad'], + physical_helper_banks_per_stage=banks_per_stage, + replicated_helper_banks_all_stages=stages * banks_per_stage, + replicated_pad_rank_mass=stages * banks_per_stage * row['pad'], + local_helper_path_rank_mass=17 * (compensation_helpers + 816), + complete_rank_mass_per_template=str(sum(mass for mass, _ in row['terms'])), + idle_slots=row['idle_slots'], max_child_rank=max(rank for _, rank in row['terms']), + nominal_kappa_interval_scaled_1e18=pair, + exact_edge_helper_budgets={name:edge_budget(row,target) for name,target in targets.items()}, + target_comparisons={name: comparison(row, target) for name, target in targets.items()})) + models.append(dict(name=name, histogram={str(k):v for k,v in hist.items()}, + compensation_helpers=dict(count=compensation_helpers, path=[1,15,1]), + K_helpers=dict(count=816,path=[17]), + scalar_ADDs=2*R+2*compensation_helpers, + compensation_scalar_primitive_bound=16*R+8*compensation_helpers+6*R3, + K_scalar_ADDs=k_word['K_full_scalar_additions'], + composite_scalar_ADDs=2*R+2*compensation_helpers+k_word['K_full_scalar_additions'], + K_scalar_primitive_bound=k_bound, + composite_scalar_primitive_bound=16*R+8*compensation_helpers+6*R3+k_bound, + scalar_charge_scope='All weighted precompensation/scatter edges remain; gather/cleanup is once per physical lane. K charge is independently recounted from the bound full-center coefficient histograms in both orientations. Physical compiler, adapters, precision/tape and all-size supplier charges remain separate.', + data_source_and_target_paths=[16], rows=rows, + scope='Conditional complete rank profile, assuming the K-word realizes this data/center/helper inventory. Scalar/compiler/precision charges and actual K admission remain separate.')) + # Fixed two-copy/full-center mask model: even removing ALL helpers and + # center pressure cannot overcome the active data lower bound at these targets. + mask = [] + center_bill = 2 * 816 * 17 + for name, target in targets.items(): + alpha = target / (1 - target) + logarithm_low, _ = oracle.log_interval(F(7)) + tail_low = 32 * alpha * logarithm_low + tail_right = F(N - center_bill, N) + require(tail_low > tail_right, 'all-L mask necessary-screen exclusion') + negative = {str(L): (L - 1)*N - L*center_bill for L in (3,5)} + require(all(v < 0 for v in negative.values()), 'first two odd stages have negative deficit') + mask.append(dict(target=name, kappa=str(target), center_bill=center_bill, + negative_deficits=negative, tail_start=7, + active_pressure_per_NL_lower=str(tail_low), deficit_per_NL_upper=str(tail_right), + gap_scaled_1e24=scaled(tail_low-tail_right, tail_low-tail_right), + status='FAILS_FIXED_MODEL_FOR_EVERY_ODD_L_GE_3', + proof='m/16>L; exp(alpha*log(m/16))-1 >= alpha*log L. Active mass2NL*16 alone gives pressure/(NL)>32alpha*log L>=32alpha*log7>1-C/N>D/(NL) for every L>=7. L3/L5 have negative deficits. Additional paid work only strengthens rejection; altered paths/factorizations remain outside scope.')) + partials = [] + for name in ('RESULT.json', 'MASK-2-RESULT.json', 'MASK-4-RESULT.json'): + route_receipt = PACKAGE / 'routes' / name + require(route_receipt.exists(), 'named partial route receipt exists: '+name) + partials.append(partial_profile(route_receipt)) + census_path = ROOT / 'research/h6-independent-audit/walsh/results.json' + census = json.loads(census_path.read_text()) + require(census['compensation_nonzeros'] == R and census['exceptional_abs_t_3_pairs'] == R3, + 'full census binds scalar counts') + names = ['research/h6-independent-audit/invoice/verify.py', + 'research/h6-compensation-network/artifact.py', + 'research/h6-compensation-network/contract/THEOREM.md', + 'research/h6-compensation-network/construction/network.py', + 'research/h6-compensation-network/routes/FULL-MASK-SCREEN.json', + 'research/h6-compensation-network/k_encoder/RESULT.json', + 'research/h6-compensation-network/k_encoder/network.py', + 'research/h6-independent-audit/walsh/results.json', + 'certificates/selected-result.json', + 'research/community-efficient500-audit/packets/1424.json'] + receipt = dict(status='PASS_EXACT_CONDITIONAL_COMPENSATION_PRICING', no_new_kappa=True, + edge_count=R, abs_t3_edges=R3, scalar_ADDs=4*R, + scalar_primitive_bounds=dict(one_sixteenth=8,five_sixteenths=11,unit=4, + total_per_invocation=24*R+6*R3, + scope='Contract emission bound for compensation alone; excludes K, adapters, controller routing, tape, precision and all-size compilation. These scalar primitives are not extra Fourier children.'), + source_hashes={name:hashlib.sha256((ROOT/name).read_bytes()).hexdigest() for name in names}, + proof_data_bindings={str(path.relative_to(ROOT)):json.loads(path.read_text()).get('proof_data') + for path in [bucket_path]+[ROOT/item['path'] for item in partials]}, + K_scalar_recount=dict(feature_nonzeros=k_word['feature_nonzeros'], + forward=k_forward,dual=k_dual,max_orientation=k_bound, + scalar_ADDs=k_word['K_full_scalar_additions']), + models=models, full_K_mask_two_center_chains_all_stage_screen=mask, + partial_routes=partials, + open_obligations='Admitted emitted K arbitrary-input word, complete representative/adapter counts, precision and tape recount, controller/child recipes, exact recovery, bit and outer transfer. Standalone cheap mask/partial routes do not implement K at frame zero for free.') + require(receipt['scalar_primitive_bounds']['total_per_invocation'] == 11548293120, + 'contract scalar primitive count') + (HERE / 'RESULT.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + print(receipt['status']) + for model in models: + print(model['name'],[(r['stages'],r['nominal_kappa_interval_scaled_1e18']) for r in model['rows']]) + print('all-L two-full-center-chain model rejected; partial routes',len(partials)) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/independent/CHECKS.json.gz b/research/h6-partial-frame-networks/independent/CHECKS.json.gz new file mode 100644 index 0000000000..a9353f8ea0 Binary files /dev/null and b/research/h6-partial-frame-networks/independent/CHECKS.json.gz differ diff --git a/research/h6-partial-frame-networks/independent/INDEPENDENT-INVENTORY.json b/research/h6-partial-frame-networks/independent/INDEPENDENT-INVENTORY.json new file mode 100644 index 0000000000..500f120da7 --- /dev/null +++ b/research/h6-partial-frame-networks/independent/INDEPENDENT-INVENTORY.json @@ -0,0 +1,25 @@ +{ + "files": { + "CHECKS.json": { + "bytes": 1088447, + "sha256": "94645c9d913fb182b13cc03f17eb9cad3c056a5a8326c666739914636b8f0393" + }, + "CHECKS.json.gz": { + "bytes": 27080, + "sha256": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc" + }, + "PROOF-INDEPENDENT.md": { + "bytes": 8868, + "sha256": "a933c6f3d89ac3ba648aea33453b6b1789719a5f42fc30b96de92afb38bb86c0" + }, + "independent_operator.py": { + "bytes": 31769, + "sha256": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382" + } + }, + "normal_optimized_raw_bytes_identical": true, + "python_executable": "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "python_version": "3.12.14", + "scientific_inputs": "Final staging cyclic and Pauli compressed receipts and original compressed historical sources", + "status": "PASS" +} diff --git a/research/h6-partial-frame-networks/independent/PROOF-INDEPENDENT.md b/research/h6-partial-frame-networks/independent/PROOF-INDEPENDENT.md new file mode 100644 index 0000000000..40015563c7 --- /dev/null +++ b/research/h6-partial-frame-networks/independent/PROOF-INDEPENDENT.md @@ -0,0 +1,166 @@ +# Independent verification of the retained logical words + +This review concerns the exact logical frame model at scientific pin +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`. It does not supply a physical +Clifford representative, a phase-sensitive compiler, a rounded implementation, +a stock/owner schedule, or a multiplication bound. Source attribution remains +with the preserved historical constructions and their cited H6/E8 lineage. +Substantial OpenAI Codex assistance; Apache-2.0 ancestry. + +## Ordinary inputs and private interfaces + +Every ordinary source, target, compensation reader, and centre has a separate +indeterminate input. In particular, the centres and compensation readers are +arbitrary dirty inputs. The endpoint statement restores their logical values +at the declared final FULL frames. Their physical entrance representatives at +ZERO are not asserted to return unchanged. + +A private forward episode is the explicitly assumed clean COPY/descent/scatter/ +ERASE interface. It copies centre c, scatters coefficients q_i into targets y_i, +and does not change c or its copy before erasure. Its ordinary operator is + +`y_i <- y_i + q_i c`. + +The separate private dual episode gathers `p=sum_i q_i y_i` from a cleared +readout, moves that readout to the centre frame, performs `c <- c-p`, and erases +the unchanged readout. Its ordinary operator is the inverse transpose of the +forward episode. No inverse transpose is assigned to a destructive CLEAR, and +no arbitrary private entering value is included in this interface. + +## Reverse covectors and the same-order dual + +For each final ordinary coordinate independently, start with its unit covector +and traverse the actual retained event list backwards. The pullback of +`dst <- dst+q src` adds q times the destination covector coefficient to the +source coefficient. Sparse exact rational dictionaries implement this rule. +Private interfaces are eliminated into their ordinary shears only after their +declared current frames and nested subspaces have been checked. + +This differs from the construction verifier's forward dense row propagation. +It produces every coefficient of every ordinary output, including all dirty +columns. Each complete operator is compared with the advertised shear. + +If the chronological ordinary factors are E_1,...,E_k, the forward matrix is +`F=E_k ... E_1`. Replacing each event, in the same chronological order, by its +inverse transpose produces + +`D=E_k^(-T) ... E_1^(-T)=F^(-T)`. + +The independent verifier also checks `D F^T=I` entry by entry. This establishes +the logical dual relationship; it does not establish a physical dual frame +implementation. + +For the cyclic modules the endpoint is `y <- y+x`, with all other logical +registers restored. The reverse calculation covers the rectangle precursor +and all static/mutable cases r=2,...,7 in both orientations: 35,976 ordinary +coefficients and 17,988 duality coefficients. + +For the selected Pauli group, independently regenerate each diagnostic feature +as `E_ic=a_i[c] q(b_i)`, with `q(b)=sum_j (-1)^j b_j^2`, then form every entry of +`K=E E^T/8192`. Both ZERO and radical-output diagnostics have nineteen source +and nineteen target coordinates and eight dirty centres. All four 46-column +operators are checked: another 8,464 ordinary coefficients and 4,232 duality +coefficients. The full 5,760-port identity is the written factor law, not a +claim of dense replay of that full operator. + +Indeed, for any compatible E and arbitrary x,y,c, the forward four-block word +is + +``` +y <- y - E c/8192 +c <- c + E^T x +y <- y + E c/8192 (through the stipulated private interface) +c <- c - E^T x. +``` + +Substitution gives `(x,y,c) -> (x,y+E E^T x/8192,c)` on every indeterminate. +The chronological dual gives `(x-E E^T y/8192,y,c)` because this kernel is +symmetric. This is an all-dimension algebraic statement conditional on the +explicit interface and compatible frames, not a finite inference from nineteen +ports. + +## Independent prefixes, frames and charges + +A second representation stores each forward row as a sparse integer vector +divided by a power of two. Addition aligns integer shifts, normalizes common +factors of two, and observes each executed output row. Private copies and +gathers are observed too, and the COPY/readout immutability condition is tested +before erasure. The resulting exact logical prefix L1 maximum and denominator +depth match the retained/fresh records. Its final rows agree with the reverse +rational calculation. This establishes logical coefficient bounds only; +coefficient-lowering temporaries and physical frame norms are absent. + +Binary frames are independently reduced by full column sweeps, rather than the +producer's incremental pivot dictionary. Ordinary climbs must be monotone and +have their declared final frames; each ADD requires equal current frames. +Private inputs must match their declared nested frames. Every positive ordinary +rank increment and every separate private descent is counted. + +The scalar price is the inherited binary Horner tariff for nonzero reduced +`q=a/2^d`: three fixed charges, one doubling after each leading binary digit, +one numerator ADD for each set bit, and d halvings. Enumerating these tokens +gives `3+floor(log2(abs(a)))+popcount(abs(a))+d`. Forward private interfaces add +two CLEARs and one COPY; dual interfaces add two CLEARs and one unit subtraction. +This is a tariff audit, not an implementation proof of those temporaries. + +The complete cyclic paths, private count/rank, rank histogram/mass, ADD count, +and scalar total are compared with each retained record. The rectangle has +rank mass 298 and scalar bills 300/312. The r-cyclic cases have rank mass 83N, +N=2r. Static bills are N(72r-37)/N(72r-34), while mutable bills are +N(54r-1)/N(54r+2). The selected Pauli bills are derived directly from E as +twice the sum of the gather and scatter coefficient tariffs, plus three or +six charges per private centre. All thirty orientations are covered. + +## Independent geometry and the shared tiling interface + +Regenerate the 120 canonical doubled E8 line representatives from the 56 +integer and 64 spinor lines. For the fresh packed product labels write + +`ell_ab = v + f_a + g_b` over F2, + +where v is the (0,0) label and f_a,g_b are the differences from its row/column. +Check this decomposition for all 14,400 labels. Check v.v=1, the 240 affine +origin pairings, both 120-by-120 factor Gram matrices, and all 120-by-120 cross +pairings. The cross pairings vanish. Bilinearity then proves the full relation + +`ell_ab . ell_cd = 1 + + (mod 2)` + +for all 14,400 squared ordered product-label pairs. This is an exact factored +certificate of those equalities, not a claim that all 207,360,000 pairs were +individually iterated. Every label is checked to be a nonzero seventeen-bit +integer. The selected q support, its U15 span, and its two-dimensional radical +W contained in U are recomputed independently. + +All 2,400 six-label frame records are independently reduced to their three +planes and three cyclic arcs. The full ordered array must agree between the +fresh cyclic and Pauli receipts. The parent wrapper additionally reconciles +all roots, forty triples, sixty orthogonal pairs, and gauges. This prevents a +shared-tariff argument from silently using a different tiling. + +The Pauli author's refinement charges the necessary target/reader join. The +old target arc has dimension three and intersects W in dimension one; W is +not contained in that arc. Thus the target path becomes `[2,2,12]` and its +reader path becomes `[2,1,1,13]`, while the supported source path is +`[1,1,12,2]`. A zero-cost W visit is not justified by this compatibility fact. + +## Defect sensitivity and limits + +The independent verifier executes three defects for every one of thirty +orientations. Reversing the sign of an actual first dirt ADD preserves its +absolute scalar price but fails the complete ordinary operator. Omitting the +actual source visit fails current-frame equality even when the logical +endpoint and scalar charge remain valid. Prepending a paid +ADD/-ADD pair +preserves the endpoint but adds eight component primitives and fails the +complete scalar invoice. + +Each of these ninety mutations must reject at its named intended gate. The +same actual predicate is then disabled, and the unexpected-acceptance oracle +must fail outside its rejection handler. These are semantic controls after +source authentication, not changed-source hash failures. Hash, type, omitted +record, coverage, optimization and output-path controls belong to the separate +package control receipt. + +This review does not certify arbitrary changed roots, another feature family, +another tiling, new physical phases, native admission of degenerate frames, +helper ownership, rounding or a complete H6 supplier. It neither reproduces +nor expands the already-published noncubic-rank and Smith theorem claims. diff --git a/research/h6-partial-frame-networks/independent/independent_operator.py b/research/h6-partial-frame-networks/independent/independent_operator.py new file mode 100644 index 0000000000..6328ab1569 --- /dev/null +++ b/research/h6-partial-frame-networks/independent/independent_operator.py @@ -0,0 +1,624 @@ +#!/usr/bin/env python3 +"""Independent reverse-covector check of C03's retained logical words. + +Substantial OpenAI Codex assistance. No producer module is imported or executed. +The data are exact historical fixtures, not a physical Clifford implementation. +""" +import argparse +from collections import Counter +import copy +from fractions import Fraction +import gzip +import hashlib +from itertools import combinations, product +import json +from pathlib import Path + +PINS = { + 'MIXED-RECTANGLE-RESULT.json': 'fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8', + 'CYCLIC-MIXED-RESULT.json': 'f65323e4d86d35f1463647ad36bddcffa21dc5eefc6ac4bbcbc8cf0ef4d0c369', + 'DYNAMIC-CYCLIC-RESULT.json': '9b9c02dac51d0989148c460f53623d51c6bd1204415991f058c83b77e36e884f', +} +FULL = tuple(1 << i for i in range(16, -1, -1)) + + +class Rejection(ValueError): + pass + + +def require(ok, gate, disabled=()): + if gate not in disabled and not ok: + raise Rejection(gate) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), allow_nan=False) + + +def unique_object(pairs): + out = {} + for k, v in pairs: + require(k not in out, 'duplicate JSON key') + out[k] = v + return out + + +def decode(raw): + return json.loads(raw, object_pairs_hook=unique_object, + parse_constant=lambda _: (_ for _ in ()).throw(Rejection('finite JSON'))) + + +def echelon(vectors): + """Full row reduction by column sweeps, independent of producer pivot insertion.""" + rows = list(vectors) + require(all(type(v) is int and 0 < v < (1 << 17) for v in rows), '17-bit nonzero frame vectors') + pivot = 0 + for bit in range(16, -1, -1): + found = next((i for i in range(pivot, len(rows)) if rows[i] & (1 << bit)), None) + if found is None: + continue + rows[pivot], rows[found] = rows[found], rows[pivot] + for i in range(len(rows)): + if i != pivot and rows[i] & (1 << bit): + rows[i] ^= rows[pivot] + pivot += 1 + return tuple(rows[:pivot]) + + +def subset(small, large): + return len(echelon(tuple(small) + tuple(large))) == len(large) + + +def coefficient(text): + q = Fraction(text) + require(q != 0 and q.denominator & (q.denominator - 1) == 0, 'nonzero dyadic coefficient') + return q + + +def horner_tokens(q): + """Enumerate the stated scalar tariff, without replaying lowering temporaries.""" + bits = bin(abs(q.numerator))[2:] + tokens = ['fixed'] * 3 + for i, bit in enumerate(bits): + if i: + tokens.append('double') + if bit == '1': + tokens.append('numerator_add') + denominator = q.denominator + while denominator > 1: + tokens.append('halve') + denominator //= 2 + return tokens + + +def bill(kind, r, dual): + if kind == 'rectangle': + return 312 if dual else 300 + return 2*r*((54*r + (2 if dual else -1)) if kind == 'dynamic' + else (72*r + (-34 if dual else -37))) + + +def flatten(fixture, dual=False, disabled=()): + """Validate frames and expand private macro algebra into ordinary shears.""" + columns = sorted(fixture['starts']) + require(set(columns) == set(fixture['ends']), 'ordinary register coverage') + frames = {name: tuple(fixture['starts'][name]) for name in columns} + for frame in frames.values(): + require(frame == echelon(frame), 'canonical entrance frames') + paths = {name: [] for name in columns} + steps, histogram = [], Counter() + charges = Counter() + scalar_adds = private_count = private_rank = 0 + for event in fixture['events']: + op = event['op'] + require(op in ('add', 'climb', 'private'), 'known event opcode') + if op == 'climb': + name, frame = event['register'], tuple(event['frame']) + require(name in frames, 'declared ordinary register') + require(frame == echelon(frame) and subset(frames[name], frame), + 'ordinary monotone frame', disabled) + rank = len(frame) - len(frames[name]) + if rank: + paths[name].append(rank) + histogram[rank] += 1 + frames[name] = frame + elif op == 'add': + dst, src, q = event['dst'], event['src'], coefficient(event['q']) + require(dst in frames and src in frames and dst != src, 'distinct declared ADD registers') + require(frames[dst] == frames[src], 'common frame equality', disabled) + if dual: + dst, src, q = src, dst, -q + steps.append((dst, src, q)) + charges.update(horner_tokens(q)) + scalar_adds += 1 + else: + center = event['center'] + targets = [(name, coefficient(q)) for name, q in event['targets']] + U = tuple(event.get('from', FULL)) + W = tuple(event.get('to', ())) + require(center in frames and all(name in frames and name != center for name, _ in targets), + 'declared private interface') + require(len({name for name, _ in targets}) == len(targets), 'distinct private targets') + require(U == echelon(U) and W == echelon(W) and subset(W, U), 'private nested frames') + require(frames[center] == U and all(frames[name] == W for name, _ in targets), + 'private entrance frames', disabled) + private_count += 1 + rank = len(U) - len(W) + private_rank += rank + histogram[rank] += 1 + # Forward COPY + scatter and dual gather + unit subtraction have + # the same ordinary operator; their clean-stream tariffs differ. + charges['private_clear'] += 2 + if dual: + charges.update(horner_tokens(Fraction(-1))) + scalar_adds += 1 + else: + charges['private_copy'] += 1 + for name, q in targets: + charges.update(horner_tokens(q)) + scalar_adds += 1 + steps.append((center, name, -q) if dual else (name, center, q)) + require(frames == {name: tuple(frame) for name, frame in fixture['ends'].items()}, + 'declared final frames', disabled) + return columns, steps, { + 'paths': paths, 'private_episodes': private_count, 'private_rank': private_rank, + 'profile': {str(k): v for k, v in sorted(histogram.items()) if v}, + 'rank_mass': sum(k*v for k, v in histogram.items()), + 'scalar_adds': scalar_adds, + 'scalar_primitives_before_real_doubling': sum(charges.values()), + 'tariff_token_counts': dict(sorted(charges.items())), + 'ordinary_shears_after_private_elimination': len(steps), + } + + +def reverse_rows(columns, steps): + """Pull each final coordinate covector backwards through the chronological word.""" + rows = [] + index = {name: i for i, name in enumerate(columns)} + for output in columns: + covector = {output: Fraction(1)} + for dst, src, q in reversed(steps): + if dst in covector: + value = covector.get(src, Fraction(0)) + q*covector[dst] + if value: + covector[src] = value + elif src in covector: + del covector[src] + rows.append({index[name]: q for name, q in covector.items()}) + return rows + + +def integer_prefixes(fixture, dual): + """Separate integer/power-of-two forward representation, including private rows.""" + columns = sorted(fixture['starts']) + rows = {name: ({i: 1}, 0) for i, name in enumerate(columns)} + peak, depth, executed_adds = Fraction(1), 0, 0 + + def observe(row): + nonlocal peak, depth + integers, exponent = row + peak = max(peak, Fraction(sum(abs(v) for v in integers.values()), 1 << exponent)) + depth = max(depth, exponent) + + def add(dst, src, q): + nonlocal executed_adds + a, ea = rows[dst] + b, eb = rows[src] + eb += q.denominator.bit_length()-1 + exponent = max(ea, eb) + value = {i: n << (exponent-ea) for i, n in a.items()} + for i, n in b.items(): + value[i] = value.get(i, 0)+(q.numerator*n << (exponent-eb)) + value = {i: n for i, n in value.items() if n} + if not value: + exponent = 0 + while exponent and all(n % 2 == 0 for n in value.values()): + value = {i: n//2 for i, n in value.items()} + exponent -= 1 + rows[dst] = value, exponent + executed_adds += 1 + observe(rows[dst]) + + for event in fixture['events']: + if event['op'] == 'climb': + continue + if event['op'] == 'add': + dst, src, q = event['dst'], event['src'], coefficient(event['q']) + add(src, dst, -q) if dual else add(dst, src, q) + else: + require('__private' not in rows, 'fresh private row') + rows['__private'] = ({}, 0) + center = event['center'] + if dual: + for target, q in event['targets']: + add('__private', target, coefficient(q)) + snapshot = rows['__private'] + add(center, '__private', Fraction(-1)) + require(rows['__private'] == snapshot, 'immutable dual readout before ERASE') + else: + rows['__private'] = copy.deepcopy(rows[center]) + snapshot = copy.deepcopy(rows[center]) + observe(rows['__private']) + for target, q in event['targets']: + add(target, '__private', coefficient(q)) + require(rows[center] == snapshot and rows['__private'] == snapshot, + 'immutable forward COPY before ERASE') + del rows['__private'] + rational = [{i: Fraction(n, 1 << exponent) for i, n in value.items()} + for value, exponent in (rows[name] for name in columns)] + return rational, {'logical_prefix_row_l1': str(peak), + 'logical_prefix_denominator_depth': depth, 'executed_adds': executed_adds} + + +def expected_rows(columns, dual, kernel=None): + index = {name: i for i, name in enumerate(columns)} + rows = [{i: Fraction(1)} for i in range(len(columns))] + n = len([x for x in columns if x.startswith('x')]) + require(all('x'+str(i) in index and 'y'+str(i) in index for i in range(n)), 'complete paired data ports') + for i in range(n): + for j in range(n): + q = Fraction(i == j) if kernel is None else Fraction(kernel[i][j]) + if q: + dst, src = ('x'+str(j), 'y'+str(i)) if dual else ('y'+str(i), 'x'+str(j)) + rows[index[dst]][index[src]] = -q if dual else q + return rows + + +def first_difference(columns, actual, wanted): + for i, (a, b) in enumerate(zip(actual, wanted)): + for j in sorted(set(a) | set(b)): + if a.get(j, 0) != b.get(j, 0): + return {'output': columns[i], 'input': columns[j], + 'actual': str(a.get(j, 0)), 'expected': str(b.get(j, 0))} + return None + + +def audit_fixture(fixture, kind, r, dual=False, disabled=(), kernel=None): + columns, steps, invoice = flatten(fixture, dual, disabled) + rows = reverse_rows(columns, steps) + wanted = expected_rows(columns, dual, kernel) + witness = first_difference(columns, rows, wanted) + require(witness is None, 'complete ordinary operator', disabled) + require(invoice['scalar_primitives_before_real_doubling'] == bill(kind, r, dual), + 'complete scalar invoice', disabled) + require(invoice['rank_mass'] == (298 if kind == 'rectangle' else 83*2*r), + 'complete rank invoice', disabled) + return columns, rows, invoice, witness + + +def require_duality(columns, forward, dual): + # Check D F^T = I at every entry, using sparse exact dot products. + for i, a in enumerate(dual): + for j, b in enumerate(forward): + require(sum(q*b.get(k, 0) for k, q in a.items()) == int(i == j), + 'same-order dual is inverse transpose') + + +def dense(columns, rows): + return [[str(row.get(j, 0)) for j in range(len(columns))] for row in rows] + + +def expect_rejection(call, intended): + try: + call() + except Rejection as error: + require(str(error) == intended, 'intended semantic rejection') + return {'gate': intended, 'rejected': True} + raise Rejection('expected rejection missing') + + +def with_deletion(call, deleted, intended): + record = expect_rejection(call, intended) + try: + expect_rejection(deleted, intended) + except Rejection as error: + require(str(error) == 'expected rejection missing', 'named-check deletion exposes defect') + else: + raise Rejection('named-check deletion retained rejection') + record['named_check_deletion_exposes_defect'] = True + return record + + +def controls(fixture, kind, r, dual): + out = [] + first = next(e for e in fixture['events'] if e['op'] == 'add') + wrong = copy.deepcopy(fixture) + changed = next(e for e in wrong['events'] if e['op'] == 'add') + changed['q'] = str(-Fraction(changed['q'])) + call = lambda: audit_fixture(wrong, kind, r, dual) + deleted = lambda: audit_fixture(wrong, kind, r, dual, ('complete ordinary operator',)) + record = with_deletion(call, deleted, 'complete ordinary operator') + record.update(mutation='first_actual_ADD_sign', coefficient_witness=deleted()[3]) + out.append(record) + paid = copy.deepcopy(fixture) + paid['events'][:0] = [dict(first, q='1', tag='paid_pair'), dict(first, q='-1', tag='paid_pair')] + call = lambda: audit_fixture(paid, kind, r, dual) + deleted = lambda: audit_fixture(paid, kind, r, dual, ('complete scalar invoice',)) + record = with_deletion(call, deleted, 'complete scalar invoice') + columns, rows, invoice, witness = deleted() + require(witness is None and invoice['scalar_primitives_before_real_doubling'] == bill(kind, r, dual)+8, + 'paid cancelling pair preserves endpoint and costs eight') + record.update(mutation='paid_cancelling_pair', same_operator=True, added_component_primitives=8) + out.append(record) + frame = copy.deepcopy(fixture) + tag = 'source_read_arc' if kind == 'dynamic' else 'source_plane' + frame['events'] = [e for e in frame['events'] if e['tag'] != tag] + call = lambda: audit_fixture(frame, kind, r, dual) + deleted = lambda: audit_fixture(frame, kind, r, dual, ('common frame equality',)) + record = with_deletion(call, deleted, 'common frame equality') + record.update(mutation='omitted_'+tag, endpoint_and_scalar_invoice_preserved=True) + out.append(record) + return out + + +def sources(source_dir): + reports = {} + for name, expected in PINS.items(): + path = source_dir/name + raw = path.read_bytes() if path.exists() else gzip.decompress((source_dir/(name+'.gz')).read_bytes()) + require(digest(raw) == expected, 'authenticated fixture receipt: '+name) + reports[name] = decode(raw) + return reports + + +def cases(reports): + a = reports['MIXED-RECTANGLE-RESULT.json'] + yield 'rectangle', None, a['fixtures'], a['orientations'] + for kind, name in [('static', 'CYCLIC-MIXED-RESULT.json'), ('dynamic', 'DYNAMIC-CYCLIC-RESULT.json')]: + require([x['r'] for x in reports[name]['cases']] == list(range(2, 8)), 'complete six cyclic orders') + for case in reports[name]['cases']: + yield kind, case['r'], case['fixture'], [case['forward'], case['dual']] + + +def pauli_fixture_check(fixture, dual=False, disabled=()): + E = [[Fraction(q) for q in row] for row in fixture['E']] + require(len(E) == 19 and all(len(row) == 8 for row in E), 'complete nineteen by eight feature matrix') + kernel = [[sum(a*b for a, b in zip(E[i], E[j]))/8192 for j in range(19)] for i in range(19)] + require(kernel == [[Fraction(q) for q in row] for row in fixture['K']], 'complete E E transpose kernel') + expected_price = 8*(6 if dual else 3) + for row in E: + for value in row: + if value: + expected_price += 2*(len(horner_tokens(value))+len(horner_tokens(value/8192))) + columns, steps, invoice = flatten(fixture, dual, disabled) + require(len(columns) == 46, 'complete forty-six ordinary input columns') + rows = reverse_rows(columns, steps) + witness = first_difference(columns, rows, expected_rows(columns, dual, kernel)) + require(witness is None, 'complete ordinary operator', disabled) + require(invoice['scalar_primitives_before_real_doubling'] == expected_price, + 'complete scalar invoice', disabled) + return columns, rows, invoice, witness + + +def pauli_controls(fixture, dual): + out = [] + bad = copy.deepcopy(fixture) + first = next(e for e in bad['events'] if e['op'] == 'add') + first['q'] = str(-Fraction(first['q'])) + call = lambda: pauli_fixture_check(bad, dual) + deleted = lambda: pauli_fixture_check(bad, dual, ('complete ordinary operator',)) + record = with_deletion(call, deleted, 'complete ordinary operator') + record.update(mutation='first_actual_dirt_ADD_sign', coefficient_witness=deleted()[3]) + out.append(record) + paid = copy.deepcopy(fixture) + first = next(e for e in paid['events'] if e['op'] == 'add') + paid['events'][:0] = [dict(first, q='1', tag='paid_pair'), dict(first, q='-1', tag='paid_pair')] + call = lambda: pauli_fixture_check(paid, dual) + deleted = lambda: pauli_fixture_check(paid, dual, ('complete scalar invoice',)) + record = with_deletion(call, deleted, 'complete scalar invoice') + require(deleted()[3] is None, 'Pauli paid cancelling pair preserves operator') + record.update(mutation='paid_cancelling_pair', same_operator=True, added_component_primitives=8) + out.append(record) + wrong_frame = copy.deepcopy(fixture) + wrong_frame['events'] = [e for e in wrong_frame['events'] if e['tag'] != 'source_U'] + call = lambda: pauli_fixture_check(wrong_frame, dual) + deleted = lambda: pauli_fixture_check(wrong_frame, dual, ('common frame equality',)) + record = with_deletion(call, deleted, 'common frame equality') + record.update(mutation='omitted_actual_source_U', endpoint_and_scalar_invoice_preserved=True) + out.append(record) + return out + + +def audit_pauli(pauli, cyclic): + require([case['name'] for case in pauli['cases']] == ['ZERO', 'radical2'], 'complete two Pauli variants') + roots = [] + for i, j in combinations(range(8), 2): + for second_sign in (-2, 2): + row = [0]*8 + row[i], row[j] = 2, second_sign + roots.append(row) + roots += [[1]+list(tail) for tail in product((-1, 1), repeat=7) + if sum(value == -1 for value in tail) % 2 == 0] + roots.sort() + require(roots == pauli['canonical_roots'] and len(roots) == 120, 'independent canonical E8 line representatives') + packed = pauli['packed_root_pairs'] + require(len(packed) == 120 and all(len(row) == 120 for row in packed), 'complete packed pair labels') + require(all(type(v) is int and 0 < v < (1 << 17) for row in packed for v in row), + 'complete seventeen-bit label domain') + base = packed[0][0] + left = [packed[i][0] ^ base for i in range(120)] + right = [packed[0][j] ^ base for j in range(120)] + parity = lambda a, b: (a & b).bit_count() % 2 + gram = [[sum(a*b for a, b in zip(x, y))//4 for y in roots] for x in roots] + require(parity(base, base) == 1, 'odd affine label origin') + for i in range(120): + require(parity(base, left[i]) == gram[0][i] % 2 and parity(base, right[i]) == gram[0][i] % 2, + 'affine origin Gram parity') + for j in range(120): + require(packed[i][j] == base ^ left[i] ^ right[j], 'complete affine product label decomposition') + wanted = (gram[i][j]+gram[0][i]+gram[0][j]) % 2 + require(parity(left[i], left[j]) == wanted and parity(right[i], right[j]) == wanted + and parity(left[i], right[j]) == 0, 'all affine factor Gram parities') + q = [sum((-1 if j % 2 else 1)*v*v for j, v in enumerate(row)) for row in roots] + require(q == pauli['quadratic_values'], 'actual selected quadratic values') + support = [j for j in range(120) if q[j]] + require(len(support) == 24 and {q[j] for j in support} == {-8, 8}, 'actual quadratic support') + U = echelon(packed[i][j] for i in range(120) for j in support) + W = echelon(w for w in range(1, 1 << 17) if all(parity(w, u) == 0 for u in U)) + require(list(U) == pauli['source_support_U'] and list(W) == pauli['radical_U_perp'] + and len(U) == 15 and len(W) == 2 and subset(W, U), 'independent U15 radical2 geometry') + result = [] + for case in pauli['cases']: + fixture = case['fixture'] + expected_E = [[str(roots[a][c]*q[b]) for c in range(8)] for a, b in fixture['ports']] + require(expected_E == fixture['E'], 'all actual diagnostic feature coefficients') + orientations, raw_rows = [], [] + for dual in (False, True): + columns, rows, invoice, _ = pauli_fixture_check(fixture, dual) + integer_rows, prefixes = integer_prefixes(fixture, dual) + require(rows == integer_rows, 'Pauli forward integer and reverse rational operators agree') + fresh = case['dual' if dual else 'forward'] + original_order = fresh['ordinary_column_order'] + require(set(original_order) == set(columns) and len(original_order) == len(columns), + 'Pauli producer column domain') + reordered = [[fresh['final_rows'][a][original_order.index(b)] for b in columns] for a in columns] + require(dense(columns, rows) == reordered, 'Pauli complete fresh operator binding') + for key in ('paths', 'private_rank'): + require(canonical(invoice[key]) == canonical(fresh[key]), 'Pauli complete invoice field: '+key) + require(invoice['scalar_primitives_before_real_doubling'] == fresh['primitive_before_real_doubling'], + 'Pauli complete scalar record binding') + require(prefixes['executed_adds'] == invoice['scalar_adds'], 'Pauli executed ADD prefix coverage') + for key in ('logical_prefix_row_l1', 'logical_prefix_denominator_depth'): + require(prefixes[key] == fresh[key], 'Pauli exact prefix field: '+key) + expected_private = 8*(15-len(case['output_frame'])) + require(invoice['private_rank'] == expected_private and invoice['rank_mass'] == 744+expected_private, + 'Pauli complete role rank invoice') + orientations.append({'orientation': 'dual' if dual else 'forward', 'ordinary_columns': columns, + 'ordinary_operator_rows': dense(columns, rows), 'invoice': invoice, + 'integer_dyadic_prefixes': prefixes, + 'production_controls': pauli_controls(fixture, dual)}) + raw_rows.append(rows) + require_duality(columns, raw_rows[0], raw_rows[1]) + result.append({'name': case['name'], 'fixture_sha256': digest(canonical(fixture).encode()), + 'orientations': orientations, 'same_order_inverse_transpose_entries': len(columns)**2}) + frames = pauli['tiling_frame_cases'] + require(len(frames) == 2400 and digest(canonical(frames).encode()) == pauli['tiling_frame_cases_sha256'], + 'complete Pauli frame census digest') + require(len({(x['triple_index'], x['b_pair_index']) for x in frames}) == 2400, + 'unique complete frame census') + for record in frames: + labels = record['labels'] + require(len(labels) == 6, 'six frame-case labels') + planes = [echelon(labels[2*g:2*g+2]) for g in range(3)] + arcs = [echelon(planes[g]+planes[(g+1)%3]) for g in range(3)] + require(canonical(planes) == canonical(record['planes']) and canonical(arcs) == canonical(record['final_arcs']), + 'independently reduced planes and arcs') + if cyclic is not None: + require(canonical(frames) == canonical(cyclic['complete_tiling']['frame_cases']), + 'complete independent cross-stage frame binding') + return {'cases': result, 'ordinary_operator_coefficients': 4*46*46, + 'duality_coefficients': 2*46*46, 'rejecting_mutations': 12, + 'named_check_deletions': 12, 'independently_reduced_frame_cases': 2400, + 'cross_stage_full_frame_arrays_compared': cyclic is not None, + 'independent_affine_Gram_domain': {'factor_lines': 120, 'product_labels': 14400, + 'all_ordered_pair_Gram_equalities_implied': 14400**2, + 'physical_signed_support_ports': 5760, + 'U_dimension': len(U), 'W_dimension': len(W)}, + 'frame_cases_sha256': digest(canonical(frames).encode())} + + +def audit(source_dir, cyclic=None, pauli=None): + reports = sources(source_dir) + fresh_cases = None if cyclic is None else list(cases(cyclic['reports'])) + records = [] + for number, (kind, r, fixture, retained) in enumerate(cases(reports)): + if fresh_cases is not None: + fresh_kind, fresh_r, fresh_fixture, fresh_orientations = fresh_cases[number] + require((fresh_kind, fresh_r) == (kind, r) and canonical(fresh_fixture) == canonical(fixture), + 'complete historical fixture binding') + orientations = [] + raw_rows = [] + for dual in (False, True): + columns, rows, invoice, _ = audit_fixture(fixture, kind, r, dual) + integer_rows, prefixes = integer_prefixes(fixture, dual) + require(integer_rows == rows, 'forward integer and reverse rational operators agree') + require(prefixes['executed_adds'] == invoice['scalar_adds'], 'all executed prefix ADDs covered') + for key in ('logical_prefix_row_l1', 'logical_prefix_denominator_depth'): + require(prefixes[key] == retained[int(dual)][key], 'retained exact prefix field: '+key) + for key in ('paths', 'private_episodes', 'private_rank', 'profile', 'rank_mass', + 'scalar_adds', 'scalar_primitives_before_real_doubling'): + require(canonical(invoice[key]) == canonical(retained[int(dual)][key]), + 'complete retained invoice field: '+key) + all_rows = dense(columns, rows) + if fresh_cases is not None: + fresh = fresh_orientations[int(dual)] + fresh_index = {name: i for i, name in enumerate(fresh['ordinary_columns'])} + require(set(fresh_index) == set(columns) and len(fresh['ordinary_columns']) == len(columns), + 'fresh complete column coverage') + reordered = [[fresh['ordinary_operator_rows'][fresh_index[a]][fresh_index[b]] + for b in columns] for a in columns] + require(all_rows == reordered, 'fresh complete ordinary operator binding') + orientations.append({'orientation': 'dual' if dual else 'forward', + 'ordinary_columns': columns, 'ordinary_operator_rows': all_rows, + 'invoice': invoice, 'integer_dyadic_prefixes': prefixes, + 'production_controls': controls(fixture, kind, r, dual)}) + raw_rows.append(rows) + require_duality(columns, raw_rows[0], raw_rows[1]) + records.append({'kind': kind, 'r': r, 'fixture_sha256': digest(canonical(fixture).encode()), + 'ordinary_input_columns': len(columns), 'chronological_events': len(fixture['events']), + 'same_order_inverse_transpose_entries': len(columns)**2, 'orientations': orientations}) + if fresh_cases is not None: + require(len(fresh_cases) == len(records), 'complete fresh case coverage') + result = {'schema': 'c03_independent_reverse_covectors.v1', 'status': 'PASS', + 'checker_sha256': digest(Path(__file__).read_bytes()), 'authenticated_fixture_receipts': PINS, + 'fresh_cyclic_receipt_compared': cyclic is not None, 'cases': records, + 'coverage': {'fixtures': len(records), 'orientations': 2*len(records), + 'ordinary_operator_coefficients': sum(2*x['ordinary_input_columns']**2 for x in records), + 'duality_coefficients': sum(x['ordinary_input_columns']**2 for x in records), + 'rejecting_mutations': 6*len(records), 'named_check_deletions': 6*len(records)}, + 'premises': ['Every ordinary source, target and dirty helper has an independent input coordinate.', + 'Frames are logical labels; helper values restore at declared final frames, not entrance frames.', + 'Private macros assume the declared clean COPY/erase contract; their arbitrary dirty input is not asserted.', + 'Horner charges are enumerated tariffs; numerical lowering temporaries and rounded precision are not replayed.', + 'No physical Clifford phases, source admission, ownership, all-size supplier or exponent result is established.']} + if pauli is not None: + result['pauli'] = audit_pauli(pauli, cyclic) + result['total_coverage'] = {'fixtures': 15, 'orientations': 30, + 'ordinary_operator_coefficients': 44440, 'duality_coefficients': 22220, + 'rejecting_mutations': 90, 'named_check_deletions': 90} + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-dir', type=Path, required=True) + parser.add_argument('--cyclic-receipt', type=Path) + parser.add_argument('--cyclic-sha256') + parser.add_argument('--pauli-receipt', type=Path) + parser.add_argument('--pauli-sha256') + parser.add_argument('--output', type=Path, required=True) + args = parser.parse_args() + require(args.output.is_absolute() and not args.output.exists(), 'fresh absolute output') + require(args.source_dir.resolve() not in args.output.resolve().parents, 'output outside source inputs') + require((args.cyclic_receipt is None) == (args.cyclic_sha256 is None), 'paired cyclic authentication arguments') + require((args.pauli_receipt is None) == (args.pauli_sha256 is None), 'paired Pauli authentication arguments') + cyclic = None + if args.cyclic_receipt is not None: + raw = args.cyclic_receipt.read_bytes() + require(digest(raw) == args.cyclic_sha256, 'authenticated fresh cyclic receipt') + cyclic = decode(gzip.decompress(raw) if args.cyclic_receipt.suffix == '.gz' else raw) + pauli = None + if args.pauli_receipt is not None: + raw = args.pauli_receipt.read_bytes() + require(digest(raw) == args.pauli_sha256, 'authenticated fresh Pauli receipt') + pauli = decode(gzip.decompress(raw) if args.pauli_receipt.suffix == '.gz' else raw) + result = audit(args.source_dir, cyclic, pauli) + if cyclic is not None: + result['fresh_cyclic_receipt_sha256'] = args.cyclic_sha256 + if pauli is not None: + result['fresh_pauli_receipt_sha256'] = args.pauli_sha256 + raw = (json.dumps(result, sort_keys=True, indent=2)+'\n').encode() + if args.output.suffix == '.gz': + raw = gzip.compress(raw, mtime=0) + args.output.parent.mkdir(parents=True, exist_ok=True) + with args.output.open('xb') as handle: + handle.write(raw) + print('PASS independent reverse covectors: '+canonical(result.get('total_coverage', result['coverage']))) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/notices/niemeier-NOTICE b/research/h6-partial-frame-networks/notices/niemeier-NOTICE new file mode 100644 index 0000000000..e6dcbd0c68 --- /dev/null +++ b/research/h6-partial-frame-networks/notices/niemeier-NOTICE @@ -0,0 +1,75 @@ +Prepared for DominikScholz with OpenAI GPT-6 Astra assistance in T3 Code. +Copyright 2026 DominikScholz. Apache-2.0, following the repository license. + +User guidance: examine the other 23 rooted Niemeier lattices, following +the suggestion attributed to David Ryan (@davidryan59) in the supplied +image. Earlier user guidance on Leech, Turyn and code-space transforms +is preserved in the three predecessor packages. This is research with +no new kappa or O(1) indexing claim. + +New work: the reproducible low-shell census; D24+ and E8^3 scalar factors; +E8^2 sections; dyadic Fano elimination; the symmetric Pauli operator-space +factorization and exhaustive support/frame certificates; scoped exact +moment screens; and the complex/bit interface analysis. + +The continuation adds rational h=16 bit labels, D16+ spinor operator +transforms, exact residual/cross ranks, the scoped support obstruction, +tensor frame embeddings and paid invoices, and the clique/matching +compensation subword with earlier cleanup. OpenAI GPT-6 Astra, running +in T3 Code, developed the research, certificates, code and write-up under +DominikScholz's direction. These are research contributions, not a claim +to a new multiplication exponent or to priority for classical identities. + +Lattice classification and theta identities credit J. H. Conway, +N. J. A. Sloane, Gabriele Nebe, Shoyu Nagaoka and Sho Takemori. The E8 +geometry, Fano plane, Walsh/Hadamard transforms and Pauli matrices are +classical constructions; no priority is claimed for them. SOURCES.txt +gives primary sources. Their use and the supplier deductions here are +distinguished from claims in those sources. + +The general binary-subspace Clifford-frame construction is inherited from +icekylinx with the OpenAI GPT-6 Astra assistance credited in +notes/general-clifford-frames.tex. The common-frame scalar interface, +transparent cleanup and copied-center lineage includes Zhihao Chen / +jacklightChen, icekylinx, Jacob Sussman and the other contributors retained +in the repository and predecessor NOTICE files. Cost-source pins are in +sources/COST-SOURCES.json; INTERFACES.txt identifies the inherited +construction sources. + +The exact interval engine comes from research/leech-lattice in PR598. +The inherited hosting relaxation credits DreamingOfClouds and the +disclosed Claude Opus 5.5 assistance via Claude Code for PR595. PR592's +reported comparison and pinned assembly source credit Jeremy Kothe / +jeremykothe2 and the disclosed Claude Opus 5.5 assistance in the omp +harness. The retained bit input credits eumemic with substantial +Anthropic Claude assistance via Claude Code for PR543, and that PR's +predecessor contributors. The cited upstream circuits and endpoints +are not represented as freshly replayed here. + +The tensor transport inherits the native E8/Hamming prototype from +research/frame-sa504, credited to icekylinx with OpenAI GPT-6 Astra +assistance and its preserved Hamming-input lineage. Its exact source hash and inherited +interface are recorded beside verify_tensor.py. Its native circuit is +not freshly replayed by this contribution. The full original attribution +is retained in that predecessor package's NOTICE. + +The continuation's PR600 profiles credit Jeremy Kothe / jeremykothe2 +with the disclosed Claude Opus 5.5 assistance in the omp harness. +Its archived source files and NOTICE.md are retained without modification +in workbench/continuation/endpoint-costs/sources, with exact hashes. +PR604's contemporary proper-endpoint result credits DreamingOfClouds +with Claude Opus 5.5 via Claude Code, building on Jeremy Kothe's PR601. +This package does not claim priority over that work for ending cold +helpers in proper subspaces. PR589's stronger bit-side comparison +likewise credits DreamingOfClouds and its retained predecessor lineage. + +Related orthogonal-basis and Pauli references credit Mordecai Waegell, +P. K. Aravind, Simon Schmidt, K. Abdukhalikov, E. Bannai and S. Suda. +The binary-code background includes A. R. Calderbank, P. J. Cameron, +W. M. Kantor and J. J. Seidel. References are listed in SOURCES.txt; +the supplier deductions and finite experiments are those made here. + +The conditional supplier framework is inherited from original OpenAI #109 +and the community research maintained by Douglas Colkitt / CrocSwap. +The predecessor NOTICE files retain their full supplier lineage. Imported +source files remain unchanged; they are not presented as newly authored. diff --git a/research/h6-partial-frame-networks/pauli/CHECKS.json.gz b/research/h6-partial-frame-networks/pauli/CHECKS.json.gz new file mode 100644 index 0000000000..017d6600ee Binary files /dev/null and b/research/h6-partial-frame-networks/pauli/CHECKS.json.gz differ diff --git a/research/h6-partial-frame-networks/pauli/ORIGINS.json b/research/h6-partial-frame-networks/pauli/ORIGINS.json new file mode 100644 index 0000000000..2b14dcbace --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/ORIGINS.json @@ -0,0 +1,170 @@ +{ + "files": [ + { + "bytes": 12954, + "file": "frozen/partial_pauli.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/partial_pauli.py" + }, + { + "bytes": 29269, + "file": "frozen/PARTIAL-PAULI-RESULT.json", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/PARTIAL-PAULI-RESULT.json" + }, + { + "bytes": 12614, + "file": "frozen/CONTINUATION.md", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CONTINUATION.md" + }, + { + "bytes": 14507, + "file": "frozen/module_tiling.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/module_tiling.py" + }, + { + "bytes": 8619, + "file": "frozen/dynamic_cyclic.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/dynamic_cyclic.py" + }, + { + "bytes": 12779, + "file": "frozen/mixed_rectangle.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/mixed_rectangle.py" + }, + { + "bytes": 15451, + "file": "frozen/pauli_partial_review.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/pauli_partial_review.py" + }, + { + "bytes": 16729, + "file": "frozen/PARTIAL-PAULI-REVIEW.json", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/PARTIAL-PAULI-REVIEW.json" + }, + { + "bytes": 685, + "file": "frozen/PAULI-FIXED-SUPPORT.json", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "sha256": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9", + "source_path": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/PAULI-FIXED-SUPPORT.json" + }, + { + "bytes": 19735, + "file": "frozen/e8_sections.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "scientific_git_blob": "b9d6fb3a39c330414965601d1aa5faf80f0a36c6", + "scientific_git_path": "research/niemeier-lattices/code/e8_sections.py", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55", + "source_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/intake/scientific/e8_sections.py" + }, + { + "bytes": 16408, + "file": "frozen/e8_cubed.py", + "runtime_role": "authenticated provenance and selected literal data; original module is not imported", + "scientific_git_blob": "d4444d142fb370498bcd9a0abec45e2f5ea0b0c5", + "scientific_git_path": "research/niemeier-lattices/code/e8_cubed.py", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "source_path": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/intake/scientific/e8_cubed.py" + }, + { + "adaptation": { + "changes": [ + "Retain selected function bodies verbatim except remove m. qualification in two tiling functions", + "Replace transitive module loading with explicit standard-library combinations/product imports and H/FULL constants", + "No change to root ordering, binary basis rule, isometry or involution algorithm" + ], + "mixed_rectangle.py": [ + "basis", + "canonical_roots", + "cong", + "dot", + "included", + "inv", + "mm", + "need", + "perp", + "symp", + "tr", + "xor" + ], + "module_tiling.py": [ + "packed_root_pairs", + "orthogonal_involution" + ] + }, + "bytes": 4858, + "file": "geometry.py", + "sha256": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25" + } + ], + "preservation": "All frozen/* files remain exact original bytes. Adapted files are separate and explicitly identified.", + "runtime_source_adaptations": { + "check.py": { + "adapted_work": [ + { + "changes": [ + "Replace transitive imports and ambient Git reads with authenticated geometry dependency", + "Remove old unbounded source loader and retain explicit supplied geometry data", + "Emit complete final rational rows and ordinary_column_order", + "Add immutable private snapshot/readout acceptance predicate", + "Use one literal common-frame predicate for ordinary ADD and private interface entrance", + "Preserve forward and dual event order, original actual-port fixture and scalar tariff" + ], + "functions": [ + "fixture", + "replay" + ], + "source": "frozen/partial_pauli.py" + }, + { + "area": "Private-interface and cost review", + "changes": [ + "Reimplement exact rational power interval arithmetic with explicit integer endpoint acceptance", + "Add actual production-gate mutations and executed named-guard deletion probes" + ], + "source": "frozen/pauli_partial_review.py" + }, + { + "area": "evaluate_operator_centers", + "changes": [ + "Translate only the selected eight Pauli feature polynomials and source-column order to standard-library arithmetic", + "Do not execute or claim a new complete 816-column factorization replay" + ], + "source": "frozen/e8_sections.py" + } + ], + "new_work": [ + "Complete eight-feature support and individual-span reconstruction", + "Exact 35-column rational support restriction rank", + "Complete 2400-case fixed cyclic compatibility census and paid source/target/reader refinement", + "Independent regrouping of the changed-role histogram", + "Exact rational power enclosures and strict sharing thresholds with shifted-exponent sign persistence" + ], + "runtime": [ + "No historical module execution or bytecode-cache loading", + "Hash all frozen input bytes before interpreting data", + "Execute only captured authenticated geometry.py bytes via compile optimize=0", + "TRIPLES literal is uniquely selected from authenticated AST without executing its module", + "Absolute external exclusive output; no runtime Git, NumPy, or ambient source paths" + ] + } + }, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90" +} diff --git a/research/h6-partial-frame-networks/pauli/OUTPUT-INVENTORY.json b/research/h6-partial-frame-networks/pauli/OUTPUT-INVENTORY.json new file mode 100644 index 0000000000..cdff915757 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/OUTPUT-INVENTORY.json @@ -0,0 +1,101 @@ +{ + "files": [ + { + "bytes": 265297, + "path": "CHECKS.json.gz", + "sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4" + }, + { + "bytes": 8671, + "path": "ORIGINS.json", + "sha256": "b4235680bf13f22e9bc408f074ad704b860dfee965876dfd005c4155d2d22382" + }, + { + "bytes": 1005, + "path": "PACKAGE-FILES.json", + "sha256": "de43b271434680161972186463a7e57e8e9c20a230431c129fe393d268cc1fe4" + }, + { + "bytes": 20174, + "path": "PROOF.md", + "sha256": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c" + }, + { + "bytes": 2246, + "path": "VALIDATION.json", + "sha256": "da0f04c3415a432c6c235983789e6911bee467ab5dde80475d24e47e93e89184" + }, + { + "bytes": 28675, + "path": "check.py", + "sha256": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66" + }, + { + "bytes": 12614, + "path": "frozen/CONTINUATION.md", + "sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df" + }, + { + "bytes": 29269, + "path": "frozen/PARTIAL-PAULI-RESULT.json", + "sha256": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0" + }, + { + "bytes": 16729, + "path": "frozen/PARTIAL-PAULI-REVIEW.json", + "sha256": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c" + }, + { + "bytes": 685, + "path": "frozen/PAULI-FIXED-SUPPORT.json", + "sha256": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9" + }, + { + "bytes": 8619, + "path": "frozen/dynamic_cyclic.py", + "sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df" + }, + { + "bytes": 16408, + "path": "frozen/e8_cubed.py", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + { + "bytes": 19735, + "path": "frozen/e8_sections.py", + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + { + "bytes": 12779, + "path": "frozen/mixed_rectangle.py", + "sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c" + }, + { + "bytes": 14507, + "path": "frozen/module_tiling.py", + "sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d" + }, + { + "bytes": 12954, + "path": "frozen/partial_pauli.py", + "sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd" + }, + { + "bytes": 15451, + "path": "frozen/pauli_partial_review.py", + "sha256": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad" + }, + { + "bytes": 4858, + "path": "geometry.py", + "sha256": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25" + } + ], + "schema": "c03_pauli_output_inventory.v1", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "self_hash_excluded": true, + "uncompressed_receipt": { + "bytes": 4021597, + "sha256": "dd2bd852b6b5b3c78f2e0cb6a5e6aff49cf4f3956aa18673bd555bfb6b069220" + } +} diff --git a/research/h6-partial-frame-networks/pauli/PACKAGE-FILES.json b/research/h6-partial-frame-networks/pauli/PACKAGE-FILES.json new file mode 100644 index 0000000000..ca2b3d4e5a --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/PACKAGE-FILES.json @@ -0,0 +1,32 @@ +{ + "excluded_preserved_development": [ + "CHECKS.json", + "CHECKS.first.json", + "CHECKS.optimized.json", + "FINAL-SCRATCH-PATH.txt", + "_replay_parts.txt" + ], + "files": [ + "CHECKS.json.gz", + "ORIGINS.json", + "OUTPUT-INVENTORY.json", + "PACKAGE-FILES.json", + "PROOF.md", + "VALIDATION.json", + "check.py", + "frozen/CONTINUATION.md", + "frozen/PARTIAL-PAULI-RESULT.json", + "frozen/PARTIAL-PAULI-REVIEW.json", + "frozen/PAULI-FIXED-SUPPORT.json", + "frozen/dynamic_cyclic.py", + "frozen/e8_cubed.py", + "frozen/e8_sections.py", + "frozen/mixed_rectangle.py", + "frozen/module_tiling.py", + "frozen/partial_pauli.py", + "frozen/pauli_partial_review.py", + "geometry.py" + ], + "notes": "Every frozen input is authenticated and required by the checker. Historical executable modules are preserved unchanged but never executed. Canonical expected receipt is exact raw JSON transported by deterministic gzip.", + "schema": "c03_pauli_package_files.v1" +} diff --git a/research/h6-partial-frame-networks/pauli/PROOF.md b/research/h6-partial-frame-networks/pauli/PROOF.md new file mode 100644 index 0000000000..e479184be6 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/PROOF.md @@ -0,0 +1,409 @@ +# Eight partial Pauli centres and a paid cyclic refinement + +This contribution proves an exact logical gather/scatter identity with arbitrary +ordinary input dirt, reconstructs its finite binary-frame data, and prices one +compatible refinement of the fixed disjoint rank-three cyclic tiling. The +refinement exists, but its complete differential power bill is adverse at the +three tested exponents. It does not supply a native phase compiler, a rounded +supplier, a physical controller, or a new multiplication bound. + +The scientific snapshot is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +`ORIGINS.json` records the unchanged historical inputs and the explicitly +adapted code. Geometry/factorization credit remains with the preserved source +authors, including Dominik Scholz and the H6 proposal by DreamingOfClouds. +This proof, the independent compatibility construction, and the portable audit +were prepared with substantial OpenAI Codex assistance. The noncubic-rank and +Smith-theorem scopes already published separately are not claimed here. + +## 1. Exact model and boundary + +Work over dyadic rationals, or over their complexification componentwise. A +register at frame A has physical value `T_A ell`, where `ell` is its logical +value. The assumed frame family has fixed invertible representatives: a move +A to B executes exactly `T_B T_A^-1`, and every scalar ADD uses identical +representatives on its two operands. For the accounting in this contribution, +a nested move A to B has the inherited tariff `dim(B)-dim(A)`; repeated moves +are separately charged. Private descent has the same dimension-difference +tariff. These are explicit historical model premises. They do not follow just +from binary containment, and this audit does not compile these degenerate +frames into native Fourier children. + +There are eight ordinary centres c, arbitrary logical source values x, +arbitrary target values y, and arbitrary centre dirt d. Sources start at their +one-dimensional binary labels, while targets and centres start at ZERO. +Sources and centres finish at FULL; each target finishes at its prescribed +16-dimensional cap. Restoration of c means restoration to logical d at FULL. +Its physical final value is `T_FULL d`, not its physical ZERO entrance value. +No uncharged raw helper-return tail is inferred. + +The private output interface is assumed explicitly: make a private snapshot +of a centre at U, descend to O contained in U, scatter from that unchanged +snapshot at O, then erase the private copy. O is either ZERO or W below. +The same-order dual uses a cleared private readout at O, gathers from the +targets, moves it to U, subtracts it from the centre, and erases it. This is a +separate private interface, not the inverse transpose of a destructive CLEAR +primitive. Clear, copy or readout, weighted ADDs, and erase are all charged. +An emitted native implementation of this interface is outside this result. + +## 2. The selected eight columns and their complete support + +Use the pinned ordering of the 120 canonical doubled E8 root lines. For a +mixed port `(a,b)` define + +``` +q(b) = sum(j=0..7) (-1)^(j mod 2) b_j^2, +E_i(a,b) = a_i q(b), 0 <= i < 8. +``` + +These features vanish on the pure ports. They do not depend on the relative +sign of the b block. In `e8_sections.evaluate_operator_centers`, the first 112 +columns are pure cubics. Each following coordinate contributes one unary, +seven Fano, 35 traceless symmetric Pauli, and one trace column. The first +nonidentity Pauli parameter is `(shift,character)=(0,1)`. Thus these are +exactly columns `120+44i`, each of weight 1 and denominator 8192. This binding +is a direct translation and inspection of the preserved evaluator, not an +execution of its NumPy-based complete 816-column implementation. The new +checker recomputes the selected polynomial values and the index arithmetic. + +The selected b-line indices are + +``` +3,4,7,10,13,15,16,18,21,23,26,28,31,33,35,36,38,40, +107,109,111,114,116,118. +``` + +On them q is +8 or -8; it vanishes on the other 96 lines. There are therefore +`120*24*2=5760` supported physical ports. The receipt contains every supported +port, its source identifier, sign, 17-bit label, and eight feature values. +Each individual feature has 3744 nonzeros: 3072 of absolute value 8 and 672 +of absolute value 16. + +The exact common support space and its orthogonal complement are + +``` +U = (65537,33024,16640,8192,4352,2048,1024,513, + 129,65,33,17,9,5,3), +W = (66303,53504). +``` + +The checker exhausts the 17-bit orthogonal complement: `dim U=15`, +`U^perp=W`, `dim W=2`, and `W` is contained in U. In particular U is +degenerate, with restricted pairing rank 13. Every supported source line is +contained in U and every supported target cap contains W. Independently +forming the eight individual feature-support spans gives U in all eight +cases, so the union space is not concealing a cheaper individual support +space for this fixed group. + +There is also a fresh, narrowly scoped support obstruction. Evaluate all 35 +nonidentity symmetric Pauli quadratic forms on the 120 canonical root lines. +Their rational evaluation rank is 35; restriction to the 96 complementary +lines has rational rank 34. Hence the space of these quadratic evaluation +functions supported on the selected 24 lines is exactly one-dimensional. +It contains q and is therefore precisely its span. This rules out simply +choosing additional independent quadratic directions with this same support +inside this 35-dimensional family. It is not a lower bound for other feature +families or other schedules. + +## 3. Arbitrary-dirt factor law and its same-order dual + +Write E for the full selected feature matrix and D=8192. All expressions in +this section are logical values. In the forward word execute + +``` +y <- y - E d/D at ZERO, +c <- d + E^T x gather at U, +y <- y + E c/D through the private U-to-O interface, +c <- c - E^T x at FULL. +``` + +The second and last lines are the actual additions to the initially dirty c. +Their combination restores c to d. Substitution in the two target lines +gives `y <- y + E E^T x/D`, for arbitrary x, y, and d. All contributing source +lines can enter U, and all contributing targets can enter O, so every ADD +uses one common frame representative. The moves to FULL and target caps +are explicit and separately charged. + +For an ADD `dst += v src`, logical inverse transpose is +`src -= v dst` in the same chronological order. Applied to the four logical +blocks, with the separate dual private readout, this gives + +``` +c <- d + E^T y/D, +x <- x - E c, +c <- c - E^T y/D, +x <- x + E c. +``` + +Thus `x <- x - E E^T y/D`, y is unchanged, and c is restored to d. This is +the same-order logical inverse transpose. It is not a reversal of the frame +climbs or a claim that the raw map has unchanged entrance and exit gauges. + +In physical coordinates the forward source-to-target block is +`T_cap(t) (E E^T/D)_(t,s) T_line(s)^-1`, and the diagonal source and centre +blocks include their declared endpoint transports. This statement follows +from the fixed-representative invariant, conditional on that frame model. + +For an independently inspectable finite diagnostic, the checker reconstructs +the historical 19 actual ports, their 46 independent ordinary input columns +(19 x, 19 y, eight c), the complete event list, and every final rational row. +It runs both orientations at O=ZERO and O=W. The receipt explicitly records +the column order. These are four complete finite operator replays with +arbitrary dirt, not clean-input tests. The full 5760-port identity follows +from the displayed factor law and exhaustive support/frame checks, not a +claim to have executed a dense 5760-port matrix replay. + +## 4. Private, scalar, and standalone visit bills + +Each selected ordinary centre has path `[15,2]` instead of `[17]`. Its private +descent costs 15 for O=ZERO and 13 for O=W, instead of 17. The eight private +descent totals are 120 and 104. In the inherited full 816-centre K context, +the private rank sum changes from 13872 to 13856 or 13840. The other 808 +centres are unchanged; this is not a new validation of their full word. + +Standalone supported sources have path `[14,2]` instead of `[16]`. Radical +output also changes each supported target from `[16]` to `[2,14]`. ZERO output +leaves the target path `[16]`. There are no new ordinary centre roles or pads. + +For nonzero reduced `v=a/2^d`, use the inherited cleared-work scalar tariff +`p(v)=3+floor(log2 |a|)+popcount(|a|)+d`. The absolute numerator choices give + +``` +p(8)=7, p(16)=8, p(8/8192)=14, p(16/8192)=13. +``` + +The selected forward word therefore costs, before real/imaginary doubling, + +``` +8 * [2*(3072*7+672*8) + 2*(3072*14+672*13) + 3] + = 1,258,008. +``` + +The final 3 charges private clear/copy/erase. In the dual, the centre/readout +unit ADD replaces copy and costs four, adding three per centre: 1,258,032. +The full K scalar figures 247217040 and 247219488 are inherited unchanged +background, explicitly labelled as such in the receipt; this checker does +not execute the full background scalar stream. + +The complete selected logical subword has forward prefix row norm 35329 and +dual prefix row norm 152, with dyadic depth 10. The forward maximum is +`1+3072*8+672*16`. The dual maximum is exhaustively evaluated over all 120 +canonical a and all eight-centre prefixes k, including k=0: + +``` +1 + 8*sum(i W -> A` path is impossible. This is the concrete obstruction to +declaring the target W visit already paid by the unchanged cyclic word. + +Set `J=A+W`. Every one of the 5760 cases has `dim J=4` and `J` is contained in +the receiving target cap. A compatible radical refinement is + +``` +target: ZERO -> W2 -> J4 -> cap16, increments [2,2,12], +reader: ZERO -> plane2 -> arc3 -> J4 -> FULL17, + increments [2,1,1,13]. +``` + +The module reader and target now share exactly J at delivery. The previous +target increments were `[3,13]`; the previous reader increments were +`[2,1,14]`. Every extra reader move is charged. ZERO private output needs no +target/reader refinement, but still pays the source U insertion. The receipt +contains all 1440 selected triple/pair/group joins, each with multiplicity +four for the two group ports and two signed modules. + +Here is a valid global chronology within the inherited logical frame model: + +1. Execute all ZERO dirt precompensations for K, cyclic modules, and residual + edge helpers. Load residual edge helpers at the original source lines + before any source leaves those lines. +2. Execute the original cyclic gathers at the required planes and arcs. + Logical source values remain immutable. Each selected source then enters + U, where the selected eight ordinary centres gather, before the sources + move on to FULL. +3. With sources at FULL, perform the unchanged 808-centre gathers and ZERO + scatters. Finish every ZERO output needed by those centres before any + affected target enters W. The selected ZERO-output variant also scatters + here. The selected radical-output variant scatters after affected targets + enter W. Selected centres move to FULL and clean up using FULL sources. +4. For affected radical modules, move readers from their arc to J and targets + from W to J, then execute the original cyclic delivery coefficients. + Unaffected modules retain their original delivery frames. +5. Move targets to their caps and deliver the preloaded residual edge helpers + there. Restore ordinary readers/centres logically at FULL using the + unchanged FULL source values. Their physical endpoint residuals remain + declared, rather than being silently replaced by raw restoration. + +This chronology changes no scalar coefficient, ordinary role, or stock. It +establishes the required common frames for the specific construction; it is +not a general result about arbitrary edge interleavings or native schedules. +The same chronology supports the logical same-order dual because the +common-frame and private-readout contracts hold in that orientation too. + +## 6. Complete changed-role histograms and signs + +Let H_r denote one rank-r event. All unchanged events, scalar work, and stock +cancel in the comparison. The centre/private contribution is + +``` +ZERO: 8*(2 H15 + H2 - 2 H17), +radical: 8*(H15 + H2 + H13 - 2 H17). +``` + +For the actual cyclic refinement the additional source contribution is +`5760*(H12+H2-H14)`. Radical output further contributes + +``` +target: 5760*(2 H2 + H12 - H3 - H13), +reader: 5760*(H1 + H13 - H14). +``` + +Consequently the complete differential histograms are + +``` +ZERO: + 5760*(H12+H2-H14) + 8*(2 H15+H2-2 H17), + +radical: + 5760*(H1+3 H2+2 H12-H3-2 H14) + + 8*(H15+H2+H13-2 H17). +``` + +Their rank masses are -16 and -32. Rank mass alone does not determine the +concave power bill. At exponent beta the differential moment is + +`m^beta * sum_r deltaH_r * r^(1-beta)`. + +For the fixed unsplit histogram, `m^beta>0` preserves its sign for every m>0. +For the full H6 invoice asserted here, restrict to admissible odd L>=3, +m>=49, whose half-width cap is at least 34. All recorded ranks at most 17 +then fit without cap splitting. The L=1 capped bill is not checked. + +The following m=49 intervals are displayed as decimal approximations only; +the receipt stores rigorous rational lower and upper endpoints at the exact +listed beta. Positive means more expensive. + +| beta | ZERO standalone | ZERO paid cyclic | radical standalone | radical paid cyclic | +| --- | ---: | ---: | ---: | ---: | +| .002 | 53.7998503675 | 50.4954366332 | 107.496538805 | 123.026676735 | +| .003 | 88.8945552816 | 83.9366685567 | 177.634095887 | 201.033060078 | +| .005 | 159.475575170 | 151.208233483 | 318.691883816 | 358.037780064 | + +The standalone differential replaces each supported source `[16]` by +`[14,2]` and, for radical output, each supported target `[16]` by `[2,14]`. +Those bills are also complete for their stated changed roles. Neither +standalone nor this actual cyclic refinement is a cost improvement at the +tested exponents, despite the lower rank mass. + +## 7. Conditional sharing threshold, without free transport + +For a different compatible word that has already paid some *identical* U/W +visits, define + +``` +d(beta) = 14^(1-beta)+2^(1-beta)-16^(1-beta) > 0, +g(beta) = the centre/private differential from Section 6. +``` + +If exactly n of these visits must newly be paid, this coarse fixed-visit +comparison improves precisely when `g(beta)+n*d(beta)<0`. The following +strict integer thresholds are certified on both neighboring integers: + +| beta | ZERO maximum new of 5760 | ZERO minimum already paid | radical maximum new of 11520 | radical minimum already paid | +| --- | ---: | ---: | ---: | ---: | +| .002 | 1314 | 4446 | 2637 | 8883 | +| .003 | 871 | 4889 | 1752 | 9768 | +| .005 | 518 | 5242 | 1044 | 10476 | + +These are conditional arithmetic thresholds, not a compatibility certificate +for a word supplying those visits. The tested cyclic word has no existing +U15 source visit or W2 target visit. Its actual compatible refinement has the +different, fully paid histogram above and fails the improvement screen. + +For every rational exponent p/q used in these comparisons, the checker +constructs integers a with +`a^q <= r^p*10^(35q) < (a+1)^q`. This encloses the power between consecutive +35-digit rationals; a floating approximation only seeds the integer search +and is not part of the acceptance condition. Interval signs, the ratio +enclosure, and both neighboring integer signs are checked exactly. + +The receipt separately certifies persistence of the signs and integer +thresholds at `beta+10^-24`. Since every profile rank is at most 17, +`log r<3`; over the intervening interval each coefficient changes by at most +`3*sum_r |deltaH_r| r * 10^-24`. The strict interval margins exceed this +bound, including the newly paid visit multiples at both threshold neighbors. +This does not assert that the displayed decimal values at beta are identical +to the values at the shifted exponent. + +## 8. Reproduction, controls, and evidence boundary + +Run the checker with a new absolute output path outside this directory (and +outside an overridden `--inputs` directory): + +``` +python3 -I -B check.py --output /absolute/external/new-receipt.json +python3 -I -O -B check.py --output /absolute/external/new-optimized-receipt.json +``` + +Only Python's standard library is required. Every source input is read once, +authenticated by SHA-256, and retained as captured bytes. Only the adapted +`geometry.py` is executed; it is compiled from those captured bytes with +`optimize=0`. Historical modules are preserved unchanged and never imported. +There are no ambient Git reads, NumPy dependencies, or bytecode-cache loads. +Outputs are opened exclusively, and no existing path is overwritten. + +The complete receipt includes all support ports, all 2400 tiling frame +cases, all selected joins, all four exact diagnostic operator matrices and +their ordered input columns, separate visit histograms, rational power +intervals, and every negative-control result. It is compared byte-for-byte +under normal and optimized Python. The package inventory records the final +source and artifact hashes. + +The 28 semantic defects actually executed are omissions of dirt prefix, +gather, private scatter, cleanup, source-U entry, and centre-U entry in both +orientations and both output variants (24); omitted target-W entry in both +radical orientations (2); the impossible unpaid `W -> old arc` target move +(1); and omission of the added reader invoice (1). Each must fail at its +intended named production predicate. The checker then runs the same defect +again with only that named predicate disabled, outside the rejection catch, +and requires successful completion. This gives 28 executed guard-deletion +sensitivities as well as 28 intended rejections. It does not claim each guard +alone covers every source, invoice, or runtime fault. + +Finite computation, written all-input identities, and implementation +admission remain distinct. The support, 35-column rank restriction, fixed +tiling census, rational inequalities, and 46-column diagnostics are finite +exact computations. The arbitrary-dirt factor identity and chronology are +written proofs under the declared frame/private interfaces. A native +phase-correct implementation for degenerate U/W, literal raw helper return, +physical source access, stock/owner allocation, full precision propagation, +and a joint asymptotic supplier remain separate obligations. diff --git a/research/h6-partial-frame-networks/pauli/VALIDATION.json b/research/h6-partial-frame-networks/pauli/VALIDATION.json new file mode 100644 index 0000000000..40a3ad5fa7 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/VALIDATION.json @@ -0,0 +1,56 @@ +{ + "checker_sha256": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66", + "cyclic_cross_contract": { + "all_frames_exact_equal": true, + "all_gauge_signs_exact_equal": true, + "all_pairs_exact_equal": true, + "all_triples_exact_equal": true, + "cyclic_receipt_gzip_sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4", + "frame_cases_sha256": "90b0a4049066b6eb08ab223ba03d8f9af95bbe688a09c4ee5c7f586ad1fdd46b" + }, + "executed_named_guard_deletions": 28, + "external_output_guards": [ + { + "exit_code": 1, + "name": "relative_output", + "rejected_by": "output must be absolute" + }, + { + "exit_code": 1, + "name": "inside_package", + "rejected_by": "output must be external to code and inputs" + }, + { + "exit_code": 1, + "name": "inside_overridden_inputs", + "rejected_by": "output must be external to code and inputs" + }, + { + "exit_code": 1, + "name": "existing_external_output", + "rejected_by": "output must be new" + } + ], + "finite_diagnostics": { + "complementary_lines": 96, + "fixed_quadratic_columns": 35, + "individual_support_spans": 8, + "ordinary_columns_each": 46, + "orientations": 2, + "physical_supported_ports": 5760, + "selected_tiling_joins": 1440, + "tiling_frame_cases": 2400, + "variants": 2 + }, + "geometry_sha256": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25", + "normal_command": "python3 -I -B check.py --output /absolute/external/new-normal.json", + "normal_optimized_complete_json_bytes_identical": true, + "optimized_command": "python3 -I -O -B check.py --output /absolute/external/new-optimized.json", + "production_rejections": 28, + "proof_sha256": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c", + "receipt_gzip_sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4", + "receipt_raw_sha256": "dd2bd852b6b5b3c78f2e0cb6a5e6aff49cf4f3956aa18673bd555bfb6b069220", + "schema": "c03_pauli_validation.v1", + "scope": "Local exact verification under the declared abstract frame and private interfaces. No hosted CI, native phase/compiler, rounded supplier, L1 capped invoice, or new kappa.", + "status": "PASS" +} diff --git a/research/h6-partial-frame-networks/pauli/check.py b/research/h6-partial-frame-networks/pauli/check.py new file mode 100644 index 0000000000..a78ecef454 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/check.py @@ -0,0 +1,552 @@ +#!/usr/bin/env python3 +"""Eight partial Pauli centres and a fully priced fixed-tiling refinement. + +Exact logical/frame-contract mathematics only. No native phase compiler, +rounded supplier, full physical schedule or multiplication bound is claimed. +Apache-2.0; substantial OpenAI Codex assistance; see preserved source notices. +""" +import argparse +import ast +from collections import Counter +from fractions import Fraction as F +from functools import lru_cache +import gzip +import hashlib +import json +from pathlib import Path +import sys +import types + +PINS = { + 'geometry.py':'05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25', + 'frozen/partial_pauli.py':'774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd', + 'frozen/PARTIAL-PAULI-RESULT.json':'048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0', + 'frozen/CONTINUATION.md':'7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df', + 'frozen/module_tiling.py':'c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d', + 'frozen/dynamic_cyclic.py':'8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df', + 'frozen/mixed_rectangle.py':'544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c', + 'frozen/pauli_partial_review.py':'01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad', + 'frozen/PARTIAL-PAULI-REVIEW.json':'0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c', + 'frozen/PAULI-FIXED-SUPPORT.json':'344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9', + 'frozen/e8_sections.py':'19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55', + 'frozen/e8_cubed.py':'ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234', +} +DISABLED = frozenset() + + +def need(ok, code): + if not ok and code not in DISABLED: + raise ValueError(code) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def serial(value): + if isinstance(value, F): + return str(value) + if isinstance(value, dict): + return {str(k):serial(v) for k,v in value.items()} + if isinstance(value, (list, tuple)): + return [serial(v) for v in value] + return value + + +def load_geometry(raw): + module = types.ModuleType('c03_authenticated_geometry') + sys.modules[module.__name__] = module + exec(compile(raw, '', 'exec', + dont_inherit=True, optimize=0), module.__dict__) + return module + + +def rational_rank(rows): + work = [list(map(F, row)) for row in rows] + if not work: + return 0 + rank = 0 + for column in range(len(work[0])): + pivot = next((i for i in range(rank, len(work)) if work[i][column]), None) + if pivot is None: + continue + work[rank], work[pivot] = work[pivot], work[rank] + scale = work[rank][column] + work[rank] = [v / scale for v in work[rank]] + for i in range(rank + 1, len(work)): + scale = work[i][column] + if scale: + work[i] = [a - scale*b for a,b in zip(work[i], work[rank])] + rank += 1 + if rank == len(work): + break + return rank + + +def setup(historical): + roots = m.canonical_roots() + packed = m.packed_root_pairs(roots) + q = [sum((-1 if j & 1 else 1)*x*x for j,x in enumerate(a)) for a in roots] + selected = [j for j,value in enumerate(q) if value] + need(len(selected) == 24 and {q[j] for j in selected} == {-8,8}, 'Pauli support24') + support = [(i,j) for i in range(120) for j in selected] + U = m.basis(packed[i][j] for i,j in support) + W = m.basis(w for w in range(1 << 17) + if all(not ((w & u).bit_count() & 1) for u in U)) + need(len(U) == 15 and len(W) == 2 and m.included(W,U), 'U15 radical2') + need(list(U) == historical['source_support_U'] and + list(W) == historical['radical_U_perp'] and + selected == historical['support_b_lines'], 'historical exact geometry binding') + features = [[roots[i][c]*q[j] for c in range(8)] for i,j in support] + individual = [] + for c in range(8): + incidence = Counter(abs(row[c]) for row in features if row[c]) + need(incidence == {8:1536,16:336}, 'half support incidence') + frame = m.basis(packed[i][j] for i,j in support if roots[i][c]) + need(frame == U, 'all eight individual feature spans equal U') + individual.append({'coordinate':c, 'frame':frame, 'signed_nonzeros':3744, + 'signed_abs8':3072, 'signed_abs16':672}) + need(all(m.included(W,m.perp(packed[i][j])) for i,j in support), 'all supported target caps contain W') + need(rational_rank(roots) == 8, 'actual eight linear feature dimensions') + chosen = []; frame = () + for i,j in support: + grown = m.basis(frame + (packed[i][j],)) + if len(grown) > len(frame): + chosen.append((i,j)); frame = grown + if len(frame) == 15: + break + linears = [] + for i in range(120): + if rational_rank([roots[j] for j in linears] + [roots[i]]) > len(linears): + linears.append(i) + if len(linears) == 8: + break + chosen += [(i,selected[0]) for i in linears] + chosen += [(105,j) for j in selected[:2]] + chosen += [(0,j) for j in range(120) if not q[j]][:2] + chosen = list(dict.fromkeys(chosen)) + need([list(x) for x in chosen] == historical['fixture_actual_ports'], 'historical actual fixture binding') + # The same 35-column symmetric traceless Pauli family as the pinned evaluator. + parameters = [(a,b) for a in range(8) for b in range(8) + if (a,b) != (0,0) and not ((a&b).bit_count() & 1)] + quadratics = [[sum((-1 if (x&b).bit_count() & 1 else 1)*r[x]*r[x^a] + for x in range(8)) for a,b in parameters] for r in roots] + outside = [row for j,row in enumerate(quadratics) if not q[j]] + need(len(parameters) == 35 and len(outside) == 96, 'complete fixed quadratic support domain') + need(rational_rank(quadratics) == 35 and rational_rank(outside) == 34, + 'fixed support exactly one quadratic direction') + need(parameters[0] == (0,1) and all(row[0] == value for row,value in zip(quadratics,q)), + 'selected evaluator Pauli column') + return roots,packed,q,support,U,W,chosen,individual,{ + 'parameters':parameters,'quadratic_values':quadratics,'outside_rank':34, + 'full_rank':35,'supported_dimension':1,'outside_rows':96} + + +def accept_nested_path(path, code): + need(all(m.included(a,b) for a,b in zip(path,path[1:])), code) + + +def path_bill(path): + return [len(b)-len(a) for a,b in zip(path,path[1:]) if len(b)>len(a)] + + +def compatibility(roots, packed, q, U, W, triples): + need(sorted(i for row in triples for i in row) == list(range(120)), 'complete acute triple partition') + pairs = m.orthogonal_involution(roots) + signs = [] + for row in triples: + sigma = [1] + [m.dot(roots[row[0]],roots[i]) for i in row[1:]] + need(all(abs(s) == 1 for s in sigma) and + all(sigma[i]*sigma[j]*m.dot(roots[row[i]],roots[row[j]]) == 1 + for i in range(3) for j in range(i)), 'actual triple signs') + signs.append(sigma) + frames = []; selected = []; census = Counter() + bills = {key:Counter() for key in ('source','target','reader')} + full = m.FULL + for ti,aa in enumerate(triples): + for bi,bb in enumerate(pairs): + labels = [packed[a][b] for a in aa for b in bb] + planes = [m.basis(labels[2*g:2*g+2]) for g in range(3)] + arcs = [m.basis(planes[g]+planes[(g+1)%3]) for g in range(3)] + need(all(len(x)==2 for x in planes) and all(len(x)==3 for x in arcs), 'r3 actual frame dimensions') + need(all(m.included(arcs[g],m.perp(labels[2*((g-1)%3)+z])) + for g in range(3) for z in range(2)), 'r3 actual target caps') + need(bool(q[bb[0]]) == bool(q[bb[1]]), 'tiling pairs preserve Pauli support') + frames.append({'triple_index':ti,'b_pair_index':bi,'labels':labels, + 'planes':planes,'final_arcs':arcs}) + if not q[bb[0]]: + continue + for group in range(3): + source_arc = arcs[(group-1)%3] + target_arc = arcs[(group+1)%3] + join = m.basis(target_arc+W) + need(m.included(source_arc,U), 'source final arc inside U') + intersection = len(W)+len(target_arc)-len(join) + need(intersection==1 and len(join)==4 and not m.included(W,target_arc), + 'target W intersection one and join four') + for z in range(2): + source_path = [m.basis((labels[2*group+z],)),planes[group],source_arc,U,full] + target_path = [(),W,join,m.perp(labels[2*group+z])] + # The reader delivering to group has origin group+1. + reader_path = [(),planes[(group+1)%3],target_arc,join,full] + for key,path in (('source',source_path),('target',target_path),('reader',reader_path)): + accept_nested_path(path, key+' refined path nested') + bills[key].update({r:2*n for r,n in Counter(path_bill(path)).items()}) + selected.append({'triple_index':ti,'b_pair_index':bi,'group':group, + 'source_arc':source_arc,'target_arc':target_arc, + 'join':join,'intersection_dimension':intersection, + 'signed_port_multiplicity':4}) + census['supported_ports'] += 4 + census['source_arc_inside_U'] += 4 + census['target_arc_does_not_contain_W'] += 4 + census['join_rank4'] += 4 + need(len(frames)==2400 and len(selected)==1440 and census['supported_ports']==5760, + 'complete tiling compatibility census') + need(bills == {'source':Counter({1:11520,12:5760,2:5760}), + 'target':Counter({2:11520,12:5760}), + 'reader':Counter({2:5760,1:11520,13:5760})}, 'actual complete refined visit invoice') + return {'a_triples':triples,'b_pairs':pairs,'gauge_signs':signs, + 'frame_cases':frames,'frame_cases_sha256':sha(canonical(frames)), + 'selected_joins':selected,'census':dict(census), + 'selected_signed_modules':960,'unchanged_signed_modules':3840, + 'actual_refined_histograms':{k:dict(v) for k,v in bills.items()}} + + +def delta_paths(changes): + delta = Counter() + for count,before,after in changes: + for r in before: + delta[r] -= count + for r in after: + delta[r] += count + return {r:n for r,n in sorted(delta.items()) if n} + + +def profile(radical, model): + private = 13 if radical else 15 + changes = [(8,[17],[15,2]),(8,[17],[private])] + if model == 'standalone': + changes.append((5760,[16],[14,2])) + if radical: + changes.append((5760,[16],[2,14])) + elif model == 'cyclic_refinement': + changes.append((5760,[1,1,14],[1,1,12,2])) + if radical: + changes += [(5760,[3,13],[2,2,12]),(5760,[2,1,14],[2,1,1,13])] + else: + need(model == 'already_paid_identical_visits','known profile model') + delta = delta_paths(changes) + need(sum(r*n for r,n in delta.items()) == (-32 if radical else -16), 'complete differential rank mass') + return delta + + +SCALE = 10**35 + + +@lru_cache(None) +def rational_power(r, exponent): + numerator, degree = exponent.numerator, exponent.denominator + target = r**numerator * SCALE**degree + # The float is only an initial speed hint. Exact integer inequalities bind + # both endpoints, so it is not part of the proof of the enclosure. + x = int(r**float(exponent)*SCALE)+SCALE//10**12 + while x**degree < target: + x *= 2 + while True: + y = ((degree-1)*x + target//x**(degree-1))//degree + if y >= x: + break + x = y + while x**degree > target: + x -= 1 + while (x+1)**degree <= target: + x += 1 + need(x**degree <= target < (x+1)**degree, 'exact rational power enclosure') + return F(x,SCALE),F(x+1,SCALE) + + +def moment(delta,beta): + lo=hi=F(0) + for r,n in delta.items(): + a,b=rational_power(r,1-beta) + lo += n*(a if n>=0 else b) + hi += n*(b if n>=0 else a) + perturbation=F(3*sum(abs(n)*r for r,n in delta.items()),10**24) + ml,mh=rational_power(49,beta) + scaled=(lo*(ml if lo>=0 else mh),hi*(mh if hi>=0 else ml)) + return {'beta':str(beta),'profile_delta':delta,'coefficient_interval':[str(lo),str(hi)], + 'm49_interval':[str(x) for x in scaled], + 'beta_plus_1e_minus24_coefficient_error_bound':str(perturbation), + 'sign':('positive' if lo>perturbation else 'negative' if hi < -perturbation else 'unresolved')} + + +def sharing_threshold(radical,beta): + fixed=moment(profile(radical,'already_paid_identical_visits'),beta) + visit=moment({14:1,2:1,16:-1},beta) + gl,gu=map(F,fixed['coefficient_interval']);dl,du=map(F,visit['coefficient_interval']) + need(gu<0 and dl>0,'threshold fixed saving and visit cost') + lower,upper=-gu/du,-gl/dl + maximum=lower.numerator//lower.denominator + need(maximum==upper.numerator//upper.denominator,'threshold unique integer boundary') + error=F(fixed['beta_plus_1e_minus24_coefficient_error_bound'])+(maximum+1)*F(visit['beta_plus_1e_minus24_coefficient_error_bound']) + need(gu+maximum*du < -error and gl+(maximum+1)*dl>error,'strict threshold on both neighboring integers') + total=11520 if radical else 5760 + return {'beta':str(beta),'total_candidate_data_visits':total, + 'maximum_new_visits_for_improvement':maximum, + 'minimum_already_paid_identical_visits':total-maximum, + 'strict_real_break_even_interval':[str(lower),str(upper)], + 'premise':'Only exactly the stated U/W data visits can be marked already paid; no compatibility or free transport is assumed.'} + + +def rejection(name, thunk, code): + global DISABLED + try: + thunk() + except ValueError as error: + need(str(error)==code,'intended control rejection: '+name) + else: + raise ValueError('mutation survived: '+name) + prior=DISABLED + try: + DISABLED=prior|{code} + thunk() + finally: + DISABLED=prior + return {'name':name,'rejected_by':code,'named_guard_deletion':'ACCEPTED', + 'scope':'Sensitivity of this production semantic gate; other independent invoice/source checks remain separate.'} + + +def fixture(roots,packed,q,U,W,chosen): + n=len(chosen) + E=[[F(roots[i][c]*q[j]) for c in range(8)] for i,j in chosen] + labels=[packed[i][j] for i,j in chosen] + K=[[sum(E[i][c]*E[j][c] for c in range(8))/8192 + for j in range(n)] for i in range(n)] + starts={f'x{i}':m.basis([labels[i]]) for i in range(n)} + starts.update({f'y{i}':() for i in range(n)}) + starts.update({f'c{c}':() for c in range(8)}) + ends={a:m.FULL for a in starts} + ends.update({f'y{i}':m.perp(labels[i]) for i in range(n)}) + events=[] + def add(dst,src,v,tag): + if v:events.append({'op':'add','dst':dst,'src':src,'q':str(v),'tag':tag}) + def climb(reg,frame,tag): + events.append({'op':'climb','register':reg,'frame':list(frame),'tag':tag}) + for i in range(n): + for c in range(8):add(f'y{i}',f'c{c}',-E[i][c]/8192,'dirt_prefix') + for i in range(n): + if any(E[i]):climb(f'x{i}',U,'source_U') + for c in range(8): + climb(f'c{c}',U,'centre_U') + for i in range(n):add(f'c{c}',f'x{i}',E[i][c],'gather') + for i in range(n):climb(f'x{i}',m.FULL,'source_FULL') + for i in range(n): + if any(E[i]):climb(f'y{i}',W,'target_W') + for c in range(8): + events.append({'op':'private','center':f'c{c}','from':list(U),'to':list(W), + 'targets':[(f'y{i}',str(E[i][c]/8192)) for i in range(n) if E[i][c]], + 'tag':'private_scatter'}) + for c in range(8): + climb(f'c{c}',m.FULL,'centre_FULL') + for i in range(n):add(f'c{c}',f'x{i}',-E[i][c],'cleanup') + for i in range(n):climb(f'y{i}',m.perp(labels[i]),'target_cap') + return {'N':n,'ports':chosen,'E':E,'K':K,'starts':starts,'ends':ends,'events':events} + +def replay(fix,dual=False,omit=None): + cols=list(fix['starts']);width=len(cols) + rows={r:[F(int(i==j)) for j in range(width)] for i,r in enumerate(cols)} + frames=dict(fix['starts']);paths={r:[] for r in cols} + private_rank=0;primitive=0;peak=F(1);depth=0 + def add(dst,src,v): + nonlocal primitive,peak,depth + need(frames[dst]==frames[src],'literal equal common frame') + rows[dst]=[x+v*y for x,y in zip(rows[dst],rows[src])] + peak=max(peak,sum(map(abs,rows[dst]))) + depth=max(depth,max(x.denominator.bit_length()-1 for x in rows[dst])) + a=abs(v.numerator) + primitive+=3+a.bit_length()-1+a.bit_count()+v.denominator.bit_length()-1 + for event in fix['events']: + if event['tag']==omit:continue + if event['op']=='climb': + r=event['register'];frame=tuple(event['frame']) + need(frame==m.basis(frame) and m.included(frames[r],frame),'ordinary monotone frame') + if len(frame)>len(frames[r]):paths[r].append(len(frame)-len(frames[r])) + frames[r]=frame + elif event['op']=='add': + dst,src,v=event['dst'],event['src'],F(event['q']) + if dual:dst,src,v=src,dst,-v + add(dst,src,v) + else: + c=event['center'];U,W=tuple(event['from']),tuple(event['to']) + targets=[(y,F(v)) for y,v in event['targets']] + need(frames[c]==U and all(frames[y]==W for y,v in targets),'literal equal common frame') + need(m.included(W,U),'private nested partial frame') + private_rank+=len(U)-len(W) + rows['p']=[F(0)]*width;frames['p']=W if dual else U;primitive+=1 + if dual: + for y,v in targets:add('p',y,v) + private_readout=list(rows['p']);frames['p']=U;add(c,'p',-F(1)) + else: + rows['p']=list(rows[c]);primitive+=1 + peak=max(peak,sum(map(abs,rows['p']))) + frames['p']=W + for y,v in targets:add(y,'p',v) + need(rows['p']==(rows[c] if not dual else private_readout), 'private immutable snapshot/readout');primitive+=1;del rows['p'];del frames['p'] + need(frames==fix['ends'],'every source,target,centre endpoint frame') + for i,r in enumerate(cols): + expected=[F(int(i==j)) for j in range(width)] + if r.startswith('x') and dual: + s=int(r[1:]) + for target in range(fix['N']):expected[cols.index(f'y{target}')]-=fix['K'][target][s] + if r.startswith('y') and not dual: + target=int(r[1:]) + for source in range(fix['N']):expected[cols.index(f'x{source}')]+=fix['K'][target][source] + need(rows[r]==expected,'all arbitrary input and dirty centre columns') + return {'final_rows':{r:[str(v) for v in rows[r]] for r in cols},'orientation':'dual' if dual else 'forward','paths':paths,'private_rank':private_rank, + 'primitive_before_real_doubling':primitive,'logical_prefix_row_l1':str(peak), + 'logical_prefix_denominator_depth':depth,'ordinary_columns':width, + 'ordinary_column_order':cols} + + +def accept_delta(actual, expected): + need({r:n for r,n in actual.items() if n} == {r:n for r,n in expected.items() if n}, + 'complete refined source target reader centre private invoice') + + +def main(): + global m + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--inputs',type=Path,default=Path(__file__).resolve().parent) + parser.add_argument('--output',type=Path,required=True) + args=parser.parse_args() + need(args.output.is_absolute(),'output must be absolute') + output=args.output.resolve() + for protected in (Path(__file__).resolve().parent,args.inputs.resolve()): + need(not output.is_relative_to(protected),'output must be external to code and inputs') + need(not args.output.exists() and not args.output.is_symlink(),'output must be new') + raw={name:(args.inputs/name).read_bytes() for name in PINS} + need({name:sha(value) for name,value in raw.items()}==PINS,'authenticated source bytes') + m=load_geometry(raw['geometry.py']) + historical=json.loads(raw['frozen/PARTIAL-PAULI-RESULT.json']) + tree=ast.parse(raw['frozen/module_tiling.py']) + triple_assignments=[node.value for node in tree.body if isinstance(node,ast.Assign) + and any(isinstance(x,ast.Name) and x.id=='TRIPLES' for x in node.targets)] + need(len(triple_assignments)==1,'unique frozen TRIPLES assignment') + triples=ast.literal_eval(triple_assignments[0]) + roots,packed,q,support,U,W,chosen,individual,fixed_support=setup(historical) + tiling=compatibility(roots,packed,q,U,W,triples) + cases=[];controls=[] + for name,out_frame in (('ZERO',()),('radical2',W)): + fix=fixture(roots,packed,q,U,out_frame,chosen) + forward,dual=replay(fix),replay(fix,True) + for tag in ('dirt_prefix','gather','private_scatter','cleanup','source_U','centre_U'): + code=('literal equal common frame' if tag in ('source_U','centre_U') + else 'all arbitrary input and dirty centre columns') + for orientation in (False,True): + controls.append(rejection(name+':'+tag+':'+str(orientation), + lambda fix=fix,orientation=orientation,tag=tag:replay(fix,orientation,tag),code)) + if out_frame: + for orientation in (False,True): + controls.append(rejection(name+':target_W:'+str(orientation), + lambda fix=fix,orientation=orientation:replay(fix,orientation,'target_W'), + 'literal equal common frame')) + radical=bool(out_frame) + deltas={model:profile(radical,model) for model in + ('standalone','already_paid_identical_visits','cyclic_refinement')} + # Independent direct regrouping of every separately named role. + expected=Counter({15:8,2:8,17:-16}) + expected[13 if radical else 15]+=8 + for r,n in ((12,5760),(2,5760),(14,-5760)): + expected[r]+=n + if radical: + for r,n in ((2,11520),(12,5760),(3,-5760),(13,-5760), + (1,5760),(13,5760),(14,-5760)): + expected[r]+=n + accept_delta(deltas['cyclic_refinement'],expected) + costs=[] + for beta in map(F,('.002','.003','.005')): + for model,delta in deltas.items(): + result=moment(delta,beta) + need(result['sign']==('negative' if model=='already_paid_identical_visits' else 'positive'), + 'complete all-arity differential sign') + costs.append({'model':model,**result}) + cases.append({'name':name,'output_frame':out_frame,'fixture':serial(fix), + 'forward':forward,'dual':dual,'full_private_rank':8*(15-len(out_frame)), + 'full_K_private_C':13872-8*(17-(15-len(out_frame))), + 'selected_centre_path':[15,2], + 'standalone_source_path':[14,2], + 'standalone_target_path':[2,14] if radical else [16], + 'cyclic_source_path':[1,1,12,2], + 'cyclic_target_path':[2,2,12] if radical else [3,13], + 'cyclic_reader_path':[2,1,1,13] if radical else [2,1,14], + 'profile_deltas':deltas,'costs':costs, + 'sharing_thresholds':[sharing_threshold(radical,beta) + for beta in map(F,('.002','.003','.005'))]}) + selected=tiling['selected_joins'][0] + controls.append(rejection('false_free_target_W_visit', + lambda:accept_nested_path([(),W,tuple(selected['target_arc'])], 'target refined path nested'), + 'target refined path nested')) + correct=profile(True,'cyclic_refinement') + omitted=Counter(correct) + for rank,count in ((1,5760),(13,5760),(14,-5760)): + omitted[rank]-=count + controls.append(rejection('omit_added_module_reader_invoice', + lambda:accept_delta(omitted,correct), + 'complete refined source target reader centre private invoice')) + need(len(controls)==28,'complete Pauli control inventory') + primitives=8*(2*(3072*7+672*8)+2*(3072*14+672*13)+3) + dual_prefix=max(F(1)+8*sum(abs(x) for x in a[:k]) + +F(3,8)*sum(abs(sum(a[i]*z[i] for i in range(k))) for z in roots) + for a in roots for k in range(9)) + need(primitives==1258008 and dual_prefix==152,'full support scalar and logical prefix census') + need(1+3072*8+672*16==35329,'full forward logical prefix') + need(2*56+16*(1+7+35+1)==816 and + [2*56+i*(1+7+35+1)+1+7 for i in range(8)]==[120+44*i for i in range(8)], + 'pinned evaluator column order translation') + physical_support=[{'a':i,'b':j,'sign':sign, + 'source_id':2160+240*i+2*j+int(sign<0), + 'label':packed[i][j],'features':[roots[i][c]*q[j] for c in range(8)]} + for i,j in support for sign in (-1,1)] + result={'status':'PASS_PARTIAL_PAULI_AND_PAID_TILING_REFINEMENT_NO_NEW_KAPPA', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90', + 'input_sha256':PINS,'canonical_roots':roots,'packed_root_pairs':packed, + 'selected_b_lines':[j for j,v in enumerate(q) if v], + 'quadratic_values':q,'source_support_U':U,'radical_U_perp':W, + 'physical_supported_ports':physical_support,'feature_specific_spans':individual, + 'source_columns':[120+44*i for i in range(8)],'feature_weight':1,'denominator':8192, + 'fixed_support_quadratic_audit':fixed_support, + 'cases':cases,'tiling_a_triples':tiling['a_triples'], + 'tiling_b_pairs':tiling['b_pairs'],'tiling_gauge_signs':tiling['gauge_signs'], + 'tiling_frame_cases':tiling['frame_cases'], + 'tiling_frame_cases_sha256':tiling['frame_cases_sha256'], + 'compatibility':{k:v for k,v in tiling.items() if k not in + ('a_triples','b_pairs','gauge_signs','frame_cases','frame_cases_sha256')}, + 'component_primitives_forward':primitives,'component_primitives_dual':primitives+24, + 'arity_scope':{'fixed_profile_sign':'m^beta is positive for every m>0', + 'H6_admitted_invoice':'odd L>=3, m>=49, half-width cap>=34; no rank17 event is split', + 'L1_capped_invoice_checked':False}, + 'full_K_component_primitives_unchanged':[247217040,247219488], + 'full_K_bill_status':'Inherited unchanged background; only selected eight-centre scalar arithmetic recomputed.', + 'logical_subword_prefix':{'forward':35329,'dual':str(dual_prefix),'dyadic_depth':10, + 'physical_precision_claim':False}, + 'controls':controls,'production_rejections':28,'executed_guard_deletions':28, + 'limits':['Ordinary centres are logically restored at FULL, not physically restored to their ZERO entrance values.', + 'COPY/descent/ERASE and same-order dual readout are explicitly assumed private interfaces; no native primitive implementation is emitted.', + 'Degenerate U15 and W2 use the inherited dimension-difference tariff; no Clifford phase/rank compiler claim is made.', + 'The 19-port 46-column diagnostic is exact; the full5760-input identity is the written factor law, not dense matrix replay.', + 'The new compatible cyclic refinement is fully charged and worsens the tested moment at every admissible arity of this fixed profile.', + 'No full supplier, shared stock admission, approximate precision, physical controller or new kappa claim.', + 'Published noncubic-rank and Smith theorem scopes are not expanded or reasserted.']} + with args.output.open('x',encoding='utf-8') as stream: + stream.write(json.dumps(serial(result),sort_keys=True,indent=2)+'\n') + print(json.dumps({'status':result['status'],'ports':len(physical_support), + 'frame_cases':len(tiling['frame_cases']),'controls':len(controls), + 'output_sha256':sha(args.output.read_bytes())})) + + +if __name__=='__main__': + main() diff --git a/research/h6-partial-frame-networks/pauli/frozen/CONTINUATION.md b/research/h6-partial-frame-networks/pauli/frozen/CONTINUATION.md new file mode 100644 index 0000000000..e5e477ed45 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/CONTINUATION.md @@ -0,0 +1,244 @@ +# Full root-product tiling and a partial-centre substitution + +Local continuation after the first area7 handoff, on the original parent +clock and scientific pin `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +**No new kappa.** The results are a concrete disjoint full root-product +tiling with its exact residual, and two fully specified partial-frame +substitutions for eight existing K centres. The parent requested both bounded +constructive checks. This document extends `EXTENSION.md`; it does not change +the scope of its positive finite words or sharp odd-Gram theorem. + +## 1. An actual tiling of all28800 root-product ports + +`module_tiling.py` stores an exact partition of the120 canonical a-root lines +into40 acute triples, with signs sigma_i making every inner product within +each triple +1. It also constructs an explicit orthogonal involution of all +120 b-root lines: for an integer D8 root, flip its second nonzero coordinate; +for a spinor root, flip coordinates4,...,7. This gives60 disjoint orthogonal +b-pairs. For each a-triple, b-pair and epsilon=+-1, use the six actual ports + +``` +(a_i,epsilon*sigma_i*b_z), i=0,1,2, z=0,1. +``` + +There are4800 disjoint r3 modules. Their product source IDs cover exactly +2160,...,30959, once each. Both pure1080-port blocks, IDs0,...,2159, are +untiled. The module coefficient is the sign conjugate of the actual cyclic +matrix from `dynamic_cyclic.py`. Every one of the172800 within-module ordered +pair coefficients is checked against `I-(t^3-4t)/48`. The2400 distinct binary +frame cases are checked for rank2 input planes, rank3 final arcs, actual cap +inclusion and nested source visits. The two epsilon variants have the same +binary frames. Reader input and output signs are charged unit scalar signs. + +Let D be the block diagonal sum of these module compensations. Exactly115200 +ordered nonzero entries of C=I-K are handled:57600 of absolute coefficient +1/16 and57600 of absolute coefficient5/16. The exact residual set is + +``` +{(t,s): actual Gram(t,s) is odd, + t and s are not in the same six-port module above}. +``` + +The pinned exhaustive full-H6 pairing receipt then gives480222720 residual +ordered entries, consisting of476916480 unit-numerator entries and3306240 +exceptional entries. This set specification and the explicit module partition +are exact; the residual dense matrix is not stored or billion-entry replayed. + +### Complete local completion, with its actual cost + +There is a legal complete local word using the existing residual edge helpers. +At ZERO precompensate the dirt of full K, the module readers and the residual +helpers. Load each residual helper from its original source at that source's +initial line. Then execute the disjoint mutable module gathers and move all +sources to FULL. Run the unchanged816-centre K while targets remain ZERO. +Deliver each module at its rank3 final arc, then finish every target cap climb. +Each residual helper advances from its source line to its rank16 target cap +and scatters there. All helpers finish at FULL and subtract their original +source accumulations. The usual same-order dual and separate dual K private +episodes give the transpose inverse. + +Thus the complete logical map is y+=(K+D+(C-D))x=y+x, with all ordinary dirt +restored. This is a specified and counted full-domain stream, not an emitted +or executed billion-event fixture. The old exact factor and all-pair support +certificates are inherited at the scientific pin. New phase/adapter, bank, +controller, precision and all-size admission are absent. + +The local native paths are source[1,1,14], target[3,13] and reader[2,1,14] +for tiled ports; pure data have their coarse[16] residual paths. The residual +edge readers have[1,15,1]. There are28800 module readers plus480222720 residual +edge readers, total480251520 ordinary compensation roles. All816 ordinary K +roles and separate private C=13872 remain paid. Every pad and idle term is in +the L5 full histogram. Its .002 normalized moment is +1.00396149237658136716079: this construction fails the requested target. + +Complete scalar component work is11794300560 forward and11794303008 dual, +before real/imaginary doubling. It saves1209600 component primitives against +the old all-edge word by replacing115200 edges with28800 changing readers. +This is a concrete finite local saving on an extremely expensive fallback; +it does not establish a useful supplier improvement or large kappa jump. + +### Residual rank budget + +For these exact modules every restricted K block is invertible. Therefore +`rank(I-D)=30960`, including the untiled pure blocks. Since rank(K)=816, + +``` +rank(C-D)=rank((I-D)-K) >=30144. +``` + +If all residual information instead crosses a private-return interface, even +ideal rank1 episodes cost at least30144, giving total private C>=44016. The +coverage deficit is at most `-30960-13056L`, negative for every L. This is a +private-return contract result, not a bound on ordinary mixed residual readers. + +Even arbitrary coefficient redesign within these disjoint r3 blocks cannot +make that particular private-residual approach meet .002. A module correction +has zero own-group2x2 blocks, so its I-D block contains I2 and has rank at +least2. Thus globally rank(I-D)>=2*4800+2160=11760, and residual rank>=10944. +Granting free residual banks and rank1 copies, total C>=24816. Active data +alone obey pressure/(NL)>.064 log L. The global minimum over L>0 of +`.064 log L+1/L` is `.064*(1+log(125/8))`; the exact rational lower interval +exceeds `1-24816/30960` by0.0414782081167369973214388. Hence every L fails +that favorable private-residual invoice. Overlapping/composed modules and +mutable ordinary residual networks are outside this argument. + +## 2. Eight actual K centres gathered at a partial frame + +`partial_pauli.py` chooses one actual traceless diagonal Pauli group from +the retained evaluator, columns120+44i for i=0,...,7, with weight1 and +denominator8192. On doubled root-product coordinates, + +``` +q(b)=sum_j (-1)^(j&1)*b_j^2, +E_i(a,b)=a_i*q(b), K_P=E E^T/8192. +``` + +All pure-port rows of these columns vanish. Exactly24 canonical b-lines +have q!=0, with q=+-8. Their two signed copies and all120 a-lines give5760 +supported ports. Each feature has3744 nonzeros:3072 of absolute value8 and +672 of absolute value16. The actual17-bit support spans U of rank15. +Its orthogonal complement W=U-perp has rank2 and lies inside U; the support +frame is degenerate with a two-dimensional radical. All supported target caps +contain W. These complete support and inclusion statements are exhausted by +standard-library exact arithmetic and saved as literal bases in the receipt. + +Allocate the same eight ordinary dirty centres c_i already charged in the +full K word. At ZERO perform `y_t-=E_ti*c_i/8192`. Supported sources climb +from their rank1 lines to U, paying14; the centres climb ZERO->U, paying15. +At U gather `c_i+=sum_s E_si*x_s`. The sources then reach FULL, paying2. +The other808 K centres retain their full-width words, and all of their ZERO +scatters precede the target moves described next. + +There are two concrete private output interfaces: + +1. **ZERO output:** copy c_i at U, descend U->ZERO paying15, scatter + `y_t+=E_ti*private/8192`, erase the private stream. Targets then make their + normal[16] climbs. Full private K bill is13856, a saving16. +2. **Radical output:** supported targets first climb ZERO->W, paying2. Copy + c_i at U, descend U->W paying13, scatter the same coefficients, erase. + Those targets finish W->Q_t, paying14. Full private K bill is13840, + a saving32. Unsupported targets make no W visit. + +In both variants each ordinary c_i finally climbs U->FULL, paying2, and +subtracts every original gather at FULL. Sources are unchanged. The arbitrary +dirt cancellation is exactly + +``` +y -= (E/8192)d; +c = d+E^T x; +y += (E/8192)c; +c -= E^T x, +``` + +so y+=K_P x and all c are restored. The private streams are independently +cleared, copied, descended, scattered and erased. In the same-order dual, +the private stream starts at the output frame, gathers E^T y/8192, ascends +to U, subtracts from c and erases there. The endpoint is x-=K_P^T y. + +This substitutes exactly the same eight feature products in the full +factorization. It does not change the cubic kernel or invoke the odd-Gram +rank theorem. The19 actual-port diagnostic contains a rank15 support witness, +all eight feature columns and zero-feature ports. It checks every one of46 +ordinary input columns in both variants/orientations, with26 meaningful +omission/frame controls. The all-supported-input identity follows from the +displayed factor product and frame inclusions; the full5760-port matrix is +not densely replayed. + +### Complete tariffs and precision boundary + +The two variants add no ordinary centre roles or helper pads. Each selected +ordinary centre has path[15,2], instead of[17]. Supported sources have +[14,2], instead of[16]. The ZERO variant has private[15], instead of[17]. +The radical variant has private[13] and additionally supported target[2,14]. +All scalar arithmetic is unchanged: the selected group costs1258008 forward +and1258032 dual component primitives. Full K retains247217040/247219488. +Every clear, copy, weighted add and restoration is included. + +The selected subword's exact full-support logical prefix maxima are35329 +forward and152 dual, denominator depth10. Forward centre rows attain +`1+3072*8+672*16=35329`. Dual source prefixes are exhausted by the120 actual +a-roots and the nine coordinate-prefix lengths; the maximum is152. This is +a logical subword range receipt. The full composed network's coefficient +temporaries, physical frame norms and approximate-child error bounds remain +unproved. + +The private saving alone does not improve the full moment when its data +visits are newly paid. Relative to the same stock, ordinary role count and +all other unchanged costs, exact `Delta(pressure-D)/L` at m49 is: + +| Target k | ZERO output | Radical output | +|---|---:|---:| +|.002|+53.7998503674671|+107.496538804777| +|.003|+88.8945552815504|+177.634095887455| +|.005|+159.475575170436|+318.691883815945| + +Positive means worse. This sign holds for every arity: stock is unchanged, +the complete rank difference is minus the private saving, and + +``` +Delta(pressure-D)/L = m^b * sum_r DeltaH_r*r^(1-b). +``` + +The coefficient is independent of m; the exact positive interval at m49 +therefore proves the sign for all L. Both ordinary-centre and private-copy +terms are present. It is not a floor derived merely from the unsplit feature's +support span, and no general splitting/factor-network lower bound is claimed. + +The substitutions are useful if a compatible dynamic network already pays +the very same U visit, and in the second variant the same W target visit. +Under that explicit sharing premise, .003 gives negative differences +-15.8570913817969 and-31.8691974392400 per L, respectively. No compatible +global transport sharing is constructed here. Distinct Pauli support frames, +source updates and overlapping feature decompositions require fresh geometry +and accounting rather than multiplying this isolated saving. + +## Reproduction and review + +``` +python3 -I -B module_tiling.py +python3 -I -O -B module_tiling.py +python3 -I -B partial_pauli.py +python3 -I -O -B partial_pauli.py +``` + +Normal and optimized executions passed. Independent specialist review of the +Pauli words also passed in `../recursive/PARTIAL-PAULI-REVIEW.json`: a separate +actual-geometry fit,18-port arbitrary-input fixture and independent power +intervals reproduce both variants and all six moment differences. The +review binds producer SHA256 +`774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd`. +The parent separately records in `../PAULI-FIXED-SUPPORT.json` that the35 +traceless quadratic directions restrict with rank34 on the96 complementary +root lines; this fixed support cannot simply share a second independent +quadratic direction. That is a finite fixed-support statement, not a general +feature-network bound. + +The final constructive source-interface question led to the independently +reviewed theorem in `SOURCE-SMITH.md`: det(C) has odd factors, exactly560 +physical rows admit algebraic unit repair, and a560-direction stable +completion must carry changed outputs and arbitrary helper dirt. This does +not code the current native K response, whose rank816 instead requires at +least30144 repairs. A new cheap complement producer and all physical coding +costs remain missing. Final optimized receipts and independent specialist +review bindings are recorded in `HANDOFF.json`. Main/protected source +checkouts remain unchanged; no public action, commit or push occurred. diff --git a/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-RESULT.json b/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-RESULT.json new file mode 100644 index 0000000000..899d676c87 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-RESULT.json @@ -0,0 +1,1317 @@ +{ + "cases": [ + { + "differentials": [ + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "53.7998503674670584751317", + "lo": "53.7998503674670584751317", + "lower": "3362490647966691154695730506372109194908868273594059560396047/62500000000000000000000000000000000000000000000000000000000", + "upper": "8406226619916727886739326265930272987272170683985148901019/156250000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "2000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "1/500" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-15.9049237916935352669725", + "lo": "-15.9049237916935352669725", + "lower": "-994057736980845954185779046388120925671484423976315626938993/62500000000000000000000000000000000000000000000000000000000", + "upper": "-12425721712260574427322238079851511570893555299703945336737/781250000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "2000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "1/500" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "88.8945552815504159369847", + "lo": "88.8945552815504159369847", + "lower": "555590970509690099606154276699034210410569420754642847373071/6250000000000000000000000000000000000000000000000000000000", + "upper": "5555909705096900996061542766990342104105694207546428473742263/62500000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "3000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "3/1000" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-15.8570913817968818038795", + "lo": "-15.8570913817968818038795", + "lower": "-19821364227246102254849424094406504689335907399738960127749/1250000000000000000000000000000000000000000000000000000000", + "upper": "-991068211362305112742471204720325234466795369986948006387417/62500000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "3000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "3/1000" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "159.475575170436479059374", + "lo": "159.475575170436479059374", + "lower": "9967223448152279941210901494755320590426372794821414980666271/62500000000000000000000000000000000000000000000000000000000", + "upper": "155737866377379374081420335855551884225412074919084609073091/976562500000000000000000000000000000000000000000000000000" + }, + "exponent_b": "5000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "1/200" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-15.7608349324893874858593", + "lo": "-15.7608349324893874858593", + "lower": "-985052183280586717866207573402444472846291600563487526065009/62500000000000000000000000000000000000000000000000000000000", + "upper": "-61565761455036669866637973337652779552893225035217970379061/3906250000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "5000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "private_rank_saving": 16, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "1/200" + } + ], + "dual": { + "logical_prefix_denominator_depth": 10, + "logical_prefix_row_l1": "523/8", + "ordinary_columns": 46, + "orientation": "dual", + "paths": { + "c0": [ + 15, + 2 + ], + "c1": [ + 15, + 2 + ], + "c2": [ + 15, + 2 + ], + "c3": [ + 15, + 2 + ], + "c4": [ + 15, + 2 + ], + "c5": [ + 15, + 2 + ], + "c6": [ + 15, + 2 + ], + "c7": [ + 15, + 2 + ], + "x0": [ + 14, + 2 + ], + "x1": [ + 14, + 2 + ], + "x10": [ + 14, + 2 + ], + "x11": [ + 14, + 2 + ], + "x12": [ + 14, + 2 + ], + "x13": [ + 14, + 2 + ], + "x14": [ + 14, + 2 + ], + "x15": [ + 14, + 2 + ], + "x16": [ + 14, + 2 + ], + "x17": [ + 16 + ], + "x18": [ + 16 + ], + "x2": [ + 14, + 2 + ], + "x3": [ + 14, + 2 + ], + "x4": [ + 14, + 2 + ], + "x5": [ + 14, + 2 + ], + "x6": [ + 14, + 2 + ], + "x7": [ + 14, + 2 + ], + "x8": [ + 14, + 2 + ], + "x9": [ + 14, + 2 + ], + "y0": [ + 16 + ], + "y1": [ + 16 + ], + "y10": [ + 16 + ], + "y11": [ + 16 + ], + "y12": [ + 16 + ], + "y13": [ + 16 + ], + "y14": [ + 16 + ], + "y15": [ + 16 + ], + "y16": [ + 16 + ], + "y17": [ + 16 + ], + "y18": [ + 16 + ], + "y2": [ + 16 + ], + "y3": [ + 16 + ], + "y4": [ + 16 + ], + "y5": [ + 16 + ], + "y6": [ + 16 + ], + "y7": [ + 16 + ], + "y8": [ + 16 + ], + "y9": [ + 16 + ] + }, + "primitive_before_real_doubling": 2232, + "private_rank": 120 + }, + "forward": { + "logical_prefix_denominator_depth": 10, + "logical_prefix_row_l1": "169", + "ordinary_columns": 46, + "orientation": "forward", + "paths": { + "c0": [ + 15, + 2 + ], + "c1": [ + 15, + 2 + ], + "c2": [ + 15, + 2 + ], + "c3": [ + 15, + 2 + ], + "c4": [ + 15, + 2 + ], + "c5": [ + 15, + 2 + ], + "c6": [ + 15, + 2 + ], + "c7": [ + 15, + 2 + ], + "x0": [ + 14, + 2 + ], + "x1": [ + 14, + 2 + ], + "x10": [ + 14, + 2 + ], + "x11": [ + 14, + 2 + ], + "x12": [ + 14, + 2 + ], + "x13": [ + 14, + 2 + ], + "x14": [ + 14, + 2 + ], + "x15": [ + 14, + 2 + ], + "x16": [ + 14, + 2 + ], + "x17": [ + 16 + ], + "x18": [ + 16 + ], + "x2": [ + 14, + 2 + ], + "x3": [ + 14, + 2 + ], + "x4": [ + 14, + 2 + ], + "x5": [ + 14, + 2 + ], + "x6": [ + 14, + 2 + ], + "x7": [ + 14, + 2 + ], + "x8": [ + 14, + 2 + ], + "x9": [ + 14, + 2 + ], + "y0": [ + 16 + ], + "y1": [ + 16 + ], + "y10": [ + 16 + ], + "y11": [ + 16 + ], + "y12": [ + 16 + ], + "y13": [ + 16 + ], + "y14": [ + 16 + ], + "y15": [ + 16 + ], + "y16": [ + 16 + ], + "y17": [ + 16 + ], + "y18": [ + 16 + ], + "y2": [ + 16 + ], + "y3": [ + 16 + ], + "y4": [ + 16 + ], + "y5": [ + 16 + ], + "y6": [ + 16 + ], + "y7": [ + 16 + ], + "y8": [ + 16 + ], + "y9": [ + 16 + ] + }, + "primitive_before_real_doubling": 2208, + "private_rank": 120 + }, + "full_K_private_C": 13856, + "full_ordinary_selected_centre_path": [ + 15, + 2 + ], + "full_selected_private_path": [ + 15 + ], + "full_source_path": [ + 14, + 2 + ], + "full_supported_target_path": [ + 16 + ], + "name": "ZERO" + }, + { + "differentials": [ + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "107.496538804777109998539", + "lo": "107.496538804777109998539", + "lower": "2687413470119427749963465378073571913647991599322037369629631/25000000000000000000000000000000000000000000000000000000000", + "upper": "13437067350597138749817326890367859568239957996610186848194299/125000000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "2000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "1/500" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-31.9130095135440774856697", + "lo": "-31.9130095135440774856697", + "lower": "-797825237838601937141742264134612182816290558734262780238401/25000000000000000000000000000000000000000000000000000000000", + "upper": "-3989126189193009685708711320673060914081452793671313901191941/125000000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "2000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "1/500" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "177.634095887454608121845", + "lo": "177.634095887454608121845", + "lower": "4440852397186365203046115924904788069079584147647787340298341/25000000000000000000000000000000000000000000000000000000000", + "upper": "22204261985931826015230579624523940345397920738238936701537849/125000000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "3000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "3/1000" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-31.8691974392399873598838", + "lo": "-31.8691974392399873598838", + "lower": "-796729935980999683997095252463745801778407514378913843796187/25000000000000000000000000000000000000000000000000000000000", + "upper": "-3983649679904998419985476262318729008892037571894569218980871/125000000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "3000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "3/1000" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "318.691883815944610212715", + "lo": "318.691883815944610212715", + "lower": "4979560684624134534573674306435468123021113005919477848187401/15625000000000000000000000000000000000000000000000000000000", + "upper": "4979560684624134534573674306435468123021113005919477848193169/15625000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "5000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": false, + "sign_for_every_arity": "WORSE_WITH_ITS_OWN_DATA_VISITS", + "target": "1/200" + }, + { + "L3_m49_margin_loss_divided_by_L": { + "hi": "-31.7809363899071228777523", + "lo": "-31.7809363899071228777523", + "lower": "-496577131092298794964880227643414408615219191772973405178239/15625000000000000000000000000000000000000000000000000000000", + "upper": "-496577131092298794964880227643414408615219191772973405178231/15625000000000000000000000000000000000000000000000000000000" + }, + "exponent_b": "5000000000000000000001/1000000000000000000000000", + "per_L_rank_count_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "private_rank_saving": 32, + "shared_source_target_transport": true, + "sign_for_every_arity": "IMPROVES_IF_VISITS_ALREADY_PAID", + "target": "1/200" + } + ], + "dual": { + "logical_prefix_denominator_depth": 10, + "logical_prefix_row_l1": "523/8", + "ordinary_columns": 46, + "orientation": "dual", + "paths": { + "c0": [ + 15, + 2 + ], + "c1": [ + 15, + 2 + ], + "c2": [ + 15, + 2 + ], + "c3": [ + 15, + 2 + ], + "c4": [ + 15, + 2 + ], + "c5": [ + 15, + 2 + ], + "c6": [ + 15, + 2 + ], + "c7": [ + 15, + 2 + ], + "x0": [ + 14, + 2 + ], + "x1": [ + 14, + 2 + ], + "x10": [ + 14, + 2 + ], + "x11": [ + 14, + 2 + ], + "x12": [ + 14, + 2 + ], + "x13": [ + 14, + 2 + ], + "x14": [ + 14, + 2 + ], + "x15": [ + 14, + 2 + ], + "x16": [ + 14, + 2 + ], + "x17": [ + 16 + ], + "x18": [ + 16 + ], + "x2": [ + 14, + 2 + ], + "x3": [ + 14, + 2 + ], + "x4": [ + 14, + 2 + ], + "x5": [ + 14, + 2 + ], + "x6": [ + 14, + 2 + ], + "x7": [ + 14, + 2 + ], + "x8": [ + 14, + 2 + ], + "x9": [ + 14, + 2 + ], + "y0": [ + 2, + 14 + ], + "y1": [ + 2, + 14 + ], + "y10": [ + 2, + 14 + ], + "y11": [ + 2, + 14 + ], + "y12": [ + 2, + 14 + ], + "y13": [ + 2, + 14 + ], + "y14": [ + 2, + 14 + ], + "y15": [ + 2, + 14 + ], + "y16": [ + 2, + 14 + ], + "y17": [ + 16 + ], + "y18": [ + 16 + ], + "y2": [ + 2, + 14 + ], + "y3": [ + 2, + 14 + ], + "y4": [ + 2, + 14 + ], + "y5": [ + 2, + 14 + ], + "y6": [ + 2, + 14 + ], + "y7": [ + 2, + 14 + ], + "y8": [ + 2, + 14 + ], + "y9": [ + 2, + 14 + ] + }, + "primitive_before_real_doubling": 2232, + "private_rank": 104 + }, + "forward": { + "logical_prefix_denominator_depth": 10, + "logical_prefix_row_l1": "169", + "ordinary_columns": 46, + "orientation": "forward", + "paths": { + "c0": [ + 15, + 2 + ], + "c1": [ + 15, + 2 + ], + "c2": [ + 15, + 2 + ], + "c3": [ + 15, + 2 + ], + "c4": [ + 15, + 2 + ], + "c5": [ + 15, + 2 + ], + "c6": [ + 15, + 2 + ], + "c7": [ + 15, + 2 + ], + "x0": [ + 14, + 2 + ], + "x1": [ + 14, + 2 + ], + "x10": [ + 14, + 2 + ], + "x11": [ + 14, + 2 + ], + "x12": [ + 14, + 2 + ], + "x13": [ + 14, + 2 + ], + "x14": [ + 14, + 2 + ], + "x15": [ + 14, + 2 + ], + "x16": [ + 14, + 2 + ], + "x17": [ + 16 + ], + "x18": [ + 16 + ], + "x2": [ + 14, + 2 + ], + "x3": [ + 14, + 2 + ], + "x4": [ + 14, + 2 + ], + "x5": [ + 14, + 2 + ], + "x6": [ + 14, + 2 + ], + "x7": [ + 14, + 2 + ], + "x8": [ + 14, + 2 + ], + "x9": [ + 14, + 2 + ], + "y0": [ + 2, + 14 + ], + "y1": [ + 2, + 14 + ], + "y10": [ + 2, + 14 + ], + "y11": [ + 2, + 14 + ], + "y12": [ + 2, + 14 + ], + "y13": [ + 2, + 14 + ], + "y14": [ + 2, + 14 + ], + "y15": [ + 2, + 14 + ], + "y16": [ + 2, + 14 + ], + "y17": [ + 16 + ], + "y18": [ + 16 + ], + "y2": [ + 2, + 14 + ], + "y3": [ + 2, + 14 + ], + "y4": [ + 2, + 14 + ], + "y5": [ + 2, + 14 + ], + "y6": [ + 2, + 14 + ], + "y7": [ + 2, + 14 + ], + "y8": [ + 2, + 14 + ], + "y9": [ + 2, + 14 + ] + }, + "primitive_before_real_doubling": 2208, + "private_rank": 104 + }, + "full_K_private_C": 13840, + "full_ordinary_selected_centre_path": [ + 15, + 2 + ], + "full_selected_private_path": [ + 13 + ], + "full_source_path": [ + 14, + 2 + ], + "full_supported_target_path": [ + 2, + 14 + ], + "name": "radical2" + } + ], + "controls": [ + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "dirt_prefix", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "dirt_prefix", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "gather", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "gather", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "private_scatter", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "private_scatter", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "cleanup", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "cleanup", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "literal equal common frame", + "omit": "source_U", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "literal equal common frame", + "omit": "source_U", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "literal equal common frame", + "omit": "centre_U", + "variant": "ZERO" + }, + { + "dual": true, + "gate": "literal equal common frame", + "omit": "centre_U", + "variant": "ZERO" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "dirt_prefix", + "variant": "radical2" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "dirt_prefix", + "variant": "radical2" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "gather", + "variant": "radical2" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "gather", + "variant": "radical2" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "private_scatter", + "variant": "radical2" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "private_scatter", + "variant": "radical2" + }, + { + "dual": false, + "gate": "all arbitrary input and dirty centre columns", + "omit": "cleanup", + "variant": "radical2" + }, + { + "dual": true, + "gate": "all arbitrary input and dirty centre columns", + "omit": "cleanup", + "variant": "radical2" + }, + { + "dual": false, + "gate": "literal equal common frame", + "omit": "source_U", + "variant": "radical2" + }, + { + "dual": true, + "gate": "literal equal common frame", + "omit": "source_U", + "variant": "radical2" + }, + { + "dual": false, + "gate": "literal equal common frame", + "omit": "centre_U", + "variant": "radical2" + }, + { + "dual": true, + "gate": "literal equal common frame", + "omit": "centre_U", + "variant": "radical2" + }, + { + "dual": false, + "gate": "private actual entrance frames", + "omit": "target_W", + "variant": "radical2" + }, + { + "dual": true, + "gate": "private actual entrance frames", + "omit": "target_W", + "variant": "radical2" + } + ], + "definition": "E_i(a,b)=a_i*sum_j(-1)^(j&1)*b_j^2 in doubled coordinates; zero on both pure blocks.", + "denominator": 8192, + "feature_abs16_each": 672, + "feature_abs8_each": 3072, + "feature_nonzeros_each": 3744, + "fixture_actual_ports": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 7 + ], + [ + 0, + 13 + ], + [ + 0, + 15 + ], + [ + 0, + 21 + ], + [ + 0, + 31 + ], + [ + 1, + 3 + ], + [ + 2, + 3 + ], + [ + 3, + 3 + ], + [ + 6, + 3 + ], + [ + 12, + 3 + ], + [ + 20, + 3 + ], + [ + 30, + 3 + ], + [ + 42, + 3 + ], + [ + 105, + 3 + ], + [ + 105, + 4 + ], + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ], + "full_component_primitives_dual": 1258032, + "full_component_primitives_forward": 1258008, + "full_scalar_primitive_difference_vs_full_width": 0, + "full_subword_logical_denominator_depth": 10, + "full_subword_logical_prefix_row_l1_dual": "152", + "full_subword_logical_prefix_row_l1_forward": 35329, + "new_ordinary_centres": 0, + "ordinary_centres": 8, + "radical_U_perp": [ + 66303, + 53504 + ], + "scope": "Two actual eight-centre partial-frame gather/scatter/restore substitutions, full support geometry and exact all-arity moment differential. Whole K identity is inherited unchanged outside these8 columns. Sources visit U once; radical variant supported targets visit Uperp once. They worsen .002/.003/.005 if these data visits are newly paid, and improve if the same visits are already part of another legal network. No transport sharing, full mixed compensation, physical phases, coefficient temporary lowering, approximate-child precision or kappa is claimed.", + "source_columns": [ + 120, + 164, + 208, + 252, + 296, + 340, + 384, + 428 + ], + "source_factor": "research/niemeier-lattices/code/e8_sections.py::evaluate_operator_centers", + "source_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_support_U": [ + 65537, + 33024, + 16640, + 8192, + 4352, + 2048, + 1024, + 513, + 129, + 65, + 33, + 17, + 9, + 5, + 3 + ], + "status": "PASS_ACTUAL_PARTIAL_PAULI_CENTRE_WORDS_AND_COMPLETE_PATH_DIFFERENTIAL_NO_NEW_KAPPA", + "support_b_lines": [ + 3, + 4, + 7, + 10, + 13, + 15, + 16, + 18, + 21, + 23, + 26, + 28, + 31, + 33, + 35, + 36, + 38, + 40, + 107, + 109, + 111, + 114, + 116, + 118 + ], + "support_ports": 5760, + "weight": 1 +} diff --git a/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-REVIEW.json b/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-REVIEW.json new file mode 100644 index 0000000000..7d79c72bfd --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/PARTIAL-PAULI-REVIEW.json @@ -0,0 +1,499 @@ +{ + "all_arity_sign_proof": "Delta moment=m^beta sum_r delta_H[r] r^(1-beta). The parent factor m^beta is positive for every arity; the exact enclosed signs are independent of m.", + "all_input_written_law": "c=d+E^T x; y=y0-E d/8192+E(d+E^T x)/8192=y0+E E^T x/8192; c restored by-E^T x. Dual phases give x-=E E^T y/8192 with d restored.", + "all_support_source_and_target_inclusions": true, + "cases": [ + { + "costs": [ + { + "beta": "1/500", + "m49_delta_interval": [ + "33624906479666911546935411537503256577452032465043118313229573056526713/625000000000000000000000000000000000000000000000000000000000000000000", + "33624906479666911546935411537503366006960800345605103545114271629955167/625000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "667283964768470330742766316326737413/12500000000000000000000000000000000", + "333641982384235165371383158163369789/6250000000000000000000000000000000" + ], + "profile_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "radical": false, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "34659/62500000000000000000000" + }, + { + "beta": "1/500", + "m49_delta_interval": [ + "-19881154739616919083715640595396462452634293898884936117637352781311881/1250000000000000000000000000000000000000000000000000000000000000000000", + "-4970288684904229770928910148849115437864302821713642484795898936157511/312500000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-197270076674402990567088853847720827/12500000000000000000000000000000000", + "-98635038337201495283544426923860411/6250000000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "radical": false, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "99/62500000000000000000000" + }, + { + "beta": "3/1000", + "m49_delta_interval": [ + "22223638820387603984237381108903135204437329898241973647073384175409579/250000000000000000000000000000000000000000000000000000000000000000000", + "868110891421390780634272699566530438773606255359350243087598391591683/9765625000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "1098283821981157323707399600683502539/12500000000000000000000000000000000", + "17160684718455583182928118760679761/195312500000000000000000000000000" + ], + "profile_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "radical": false, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "34659/62500000000000000000000" + }, + { + "beta": "3/1000", + "m49_delta_interval": [ + "-9910682113623051127424742003961477007930678941039063369016265042489023/625000000000000000000000000000000000000000000000000000000000000000000", + "-123883526420288139092809275049518458212978445113335471672762493663953/7812500000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-195912864102250156491701279199061541/12500000000000000000000000000000000", + "-6122277003195317390365664974970673/390625000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "radical": false, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "99/62500000000000000000000" + }, + { + "beta": "1/200", + "m49_delta_interval": [ + "4983611724076139970604343826804424222552163887988431901576805718862277/31250000000000000000000000000000000000000000000000000000000000000000", + "199344468963045598824173753072177191611267806874395541043401791671150371/1250000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "488757256607864326666378682167405669/3125000000000000000000000000000000", + "1955029026431457306665514728669624841/12500000000000000000000000000000000" + ], + "profile_delta": { + "2": 5768, + "14": 5760, + "15": 16, + "16": -5760, + "17": -16 + }, + "radical": false, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "34659/62500000000000000000000" + }, + { + "beta": "1/200", + "m49_delta_interval": [ + "-4925260916402933589331052968899839314067421023503418615824135642341401/312500000000000000000000000000000000000000000000000000000000000000000", + "-1970104366561173435732421187559935655323100270400325743055132864715207/125000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-48303462365445213404655809927292971/3125000000000000000000000000000000", + "-193213849461780853618623239709171879/12500000000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "15": 16, + "17": -16 + }, + "radical": false, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "99/62500000000000000000000" + } + ], + "dual": { + "all_input_shear": true, + "fixture_ports": 18, + "ordinary_input_columns": 44, + "ordinary_path_histogram": { + "2": 24, + "14": 16, + "15": 8, + "16": 20 + }, + "private_rank": 120 + }, + "forward": { + "all_input_shear": true, + "fixture_ports": 18, + "ordinary_input_columns": 44, + "ordinary_path_histogram": { + "2": 24, + "14": 16, + "15": 8, + "16": 20 + }, + "private_rank": 120 + }, + "full_K_private_bill": 13856, + "radical": false + }, + { + "costs": [ + { + "beta": "1/500", + "m49_delta_interval": [ + "67185336752985693749042879750632347804479268095077888222335997900987007/625000000000000000000000000000000000000000000000000000000000000000000", + "16796334188246423437260719937658141602725884484795378063251383480092037/156250000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "1333288403640527344230697813587484307/12500000000000000000000000000000000", + "166661050455065918028837226698436079/1562500000000000000000000000000000" + ], + "profile_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "radical": true, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "2163/1953125000000000000000" + }, + { + "beta": "1/500", + "m49_delta_interval": [ + "-39891261891930096857087167839541255607397707364199886298355821052747119/1250000000000000000000000000000000000000000000000000000000000000000000", + "-2493203868245631053567947989971328419229438886334575768623649443897121/78125000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-395819679245219298389012526761432173/12500000000000000000000000000000000", + "-49477459905652412298626565845179021/1562500000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "radical": true, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "3/1953125000000000000000" + }, + { + "beta": "3/1000", + "m49_delta_interval": [ + "5551065496482956503805449039604497876704304982820771188677037404291173/31250000000000000000000000000000000000000000000000000000000000000000", + "111021309929659130076108980792090177421027483742957931048760946127369207/625000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "274331556538440003873029687857050693/1562500000000000000000000000000000", + "2194652452307520030984237502856409869/12500000000000000000000000000000000" + ], + "profile_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "radical": true, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "2163/1953125000000000000000" + }, + { + "beta": "3/1000", + "m49_delta_interval": [ + "-2489781049940624012490926095043584063114937943033734926892444016437781/78125000000000000000000000000000000000000000000000000000000000000000", + "-7967299359809996839970963504139468822045228933510106927525119090919571/250000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-49217614982411866176745532113590327/1562500000000000000000000000000000", + "-393740919859294929413964256908722611/12500000000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "radical": true, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "3/1953125000000000000000" + }, + { + "beta": "1/200", + "m49_delta_interval": [ + "39836485476993076276580545625473573900322998269947898071676915807543837/125000000000000000000000000000000000000000000000000000000000000000000", + "199182427384965381382902728127368091954294637984539551916983610342865467/625000000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "3906879675351027769901690368329260989/12500000000000000000000000000000000", + "1953439837675513884950845184164632657/6250000000000000000000000000000000" + ], + "profile_delta": { + "2": 11528, + "13": 8, + "14": 11520, + "15": 8, + "16": -11520, + "17": -16 + }, + "radical": true, + "shared_data_visits": false, + "sign": "worsens with new data visits", + "tiny_exponent_perturbation_bound": "2163/1953125000000000000000" + }, + { + "beta": "1/200", + "m49_delta_interval": [ + "-39726170487383903597190473640816913316660874039509763765307473582259361/1250000000000000000000000000000000000000000000000000000000000000000000", + "-1986308524369195179859523682040845620861498283791582484229996547044479/62500000000000000000000000000000000000000000000000000000000000000000" + ], + "normalized_delta_interval": [ + "-389606076435448550666585568428328131/12500000000000000000000000000000000", + "-194803038217724275333292784214164063/6250000000000000000000000000000000" + ], + "profile_delta": { + "2": 8, + "13": 8, + "15": 8, + "17": -16 + }, + "radical": true, + "shared_data_visits": true, + "sign": "improves conditionally", + "tiny_exponent_perturbation_bound": "3/1953125000000000000000" + } + ], + "dual": { + "all_input_shear": true, + "fixture_ports": 18, + "ordinary_input_columns": 44, + "ordinary_path_histogram": { + "2": 40, + "14": 32, + "15": 8, + "16": 4 + }, + "private_rank": 104 + }, + "forward": { + "all_input_shear": true, + "fixture_ports": 18, + "ordinary_input_columns": 44, + "ordinary_path_histogram": { + "2": 40, + "14": 32, + "15": 8, + "16": 4 + }, + "private_rank": 104 + }, + "full_K_private_bill": 13840, + "radical": true + } + ], + "coefficient_denominator": 8192, + "controls": [ + "all independent source/target/dirty centre columns", + "all independent source/target/dirty centre columns", + "all independent source/target/dirty centre columns", + "independent actual common frame", + "all independent source/target/dirty centre columns", + "all independent source/target/dirty centre columns", + "all independent source/target/dirty centre columns", + "all independent source/target/dirty centre columns", + "independent actual common frame", + "all independent source/target/dirty centre columns", + "independent actual common frame" + ], + "feature_columns": [ + 120, + 164, + 208, + 252, + 296, + 340, + 384, + 428 + ], + "feature_incidence_each": 3744, + "fixture_ports": [ + [ + 0, + 3, + -1 + ], + [ + 0, + 4, + -1 + ], + [ + 0, + 7, + -1 + ], + [ + 0, + 13, + -1 + ], + [ + 0, + 15, + -1 + ], + [ + 0, + 21, + -1 + ], + [ + 0, + 31, + -1 + ], + [ + 1, + 3, + -1 + ], + [ + 2, + 3, + -1 + ], + [ + 3, + 3, + -1 + ], + [ + 6, + 3, + -1 + ], + [ + 12, + 3, + -1 + ], + [ + 20, + 3, + -1 + ], + [ + 30, + 3, + -1 + ], + [ + 42, + 3, + -1 + ], + [ + 106, + 3, + -1 + ], + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ] + ], + "frame_binding": "Intrinsic pairing coordinates use the actual E8 Gram inverse. The canonical17-bit fit is an isometry of this nondegenerate bilinear space; dimensions, inclusions and orthogonal complements therefore transfer to its fixed actual labels. No new free physical permutation is asserted.", + "full_component_dual_primitive_bound": 1258032, + "full_component_forward_primitive_bound": 1258008, + "intrinsic_U": [ + 65536, + 32768, + 17152, + 8960, + 4096, + 2048, + 1792, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "intrinsic_U_perp": [ + 32768, + 32512 + ], + "intrinsic_bilinear_form": [ + 128, + 212, + 2, + 80, + 10, + 64, + 42, + 3, + 32768, + 54272, + 512, + 20480, + 2560, + 16384, + 10752, + 768, + 65536 + ], + "limits": [ + "full5760 support geometry and an all-parameter written arbitrary-input factor identity; bounded actual-port fixture is not dense fullK replay", + "private snapshot/readout erasure uses the inherited exact centre-copy and same-order dual interface", + "physical Clifford phases/adapters, coefficient temporary lowering, approximate children, precision and tape remain separate", + "conditional sharing requires already-paid identical U and Uperp visits in a compatible chronology; none is supplied here", + "no completed H6 supplier or kappa gain" + ], + "physical_supported_ports": 5760, + "primary_sources": { + "research/niemeier-lattices/code/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "research/niemeier-lattices/code/e8_sections.py": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + "reviewed_producer_sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "status": "PASS_INDEPENDENT_PARTIAL_PAULI_GEOMETRY_DIRTY_WORD_AND_COMPLETE_COST" +} diff --git a/research/h6-partial-frame-networks/pauli/frozen/PAULI-FIXED-SUPPORT.json b/research/h6-partial-frame-networks/pauli/frozen/PAULI-FIXED-SUPPORT.json new file mode 100644 index 0000000000..661b7f3b6e --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/PAULI-FIXED-SUPPORT.json @@ -0,0 +1,9 @@ +{ + "status": "PASS_FIXED_PAULI_SUPPORT_QUADRATIC_DIMENSION_ONE", + "full_dimension": 35, + "outside_rows": 96, + "outside_rank": 34, + "supported_dimension": 1, + "source_sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "scope": "Finite exact rational rank on all120 canonical E8 roots. Only one traceless quadratic direction vanishes on the96 outside roots. Multiplication by the8 independent a-linear directions therefore gives at most8 centres within this fixed a-linear times quadratic support model. Other feature sectors, changed supports, shared visits with other supplier components and general helper circuits are not excluded. No new kappa." +} diff --git a/research/h6-partial-frame-networks/pauli/frozen/dynamic_cyclic.py b/research/h6-partial-frame-networks/pauli/frozen/dynamic_cyclic.py new file mode 100644 index 0000000000..2c942dfebe --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/dynamic_cyclic.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""Mutable cyclic readers: exact input transport and dirty cleanup. + +Each reader accumulates successive source groups at nested frames, then +delivers once to the excluded group. Actual E8 cases r=2..7 only. No full +H6 arc network or improved kappa is inferred from conditional tariffs. +""" +from fractions import Fraction as F +from pathlib import Path +import importlib.util +import json + +HERE = Path(__file__).resolve().parent + + +def load(name, file): + spec = importlib.util.spec_from_file_location(name, HERE/file) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +c = load('dynamic_static_cyclic', 'cyclic_mixed.py') +m = c.m +b = load('dynamic_exact_budget', 'optimistic_budget.py') +need = m.need + + +def fixture(r): + fix = c.fixture(r) + n = fix['N'] + k = [[F(q) for q in row] for row in fix['K']] + planes = [tuple(p) for p in fix['planes']] + arc = {(g, depth): tuple(fix['arcs'][str(g)+':'+str(depth)]) + for g in range(r) for depth in range(1, r)} + # L is now the cyclic all-but-excluded prefix accumulation. R sends + # each final packet to only that excluded target pair. + ell = [[F(0)]*n for _ in range(n)] + decoder = [[F(0)]*n for _ in range(n)] + for g in range(r): + for depth in range(r-1): + source = (g+depth) % r + ell[2*g][2*source] = ell[2*g][2*source+1] = 1 + ell[2*g+1][2*source] = 1 + ell[2*g+1][2*source+1] = -1 + t = (g-1) % r + for z in range(2): + decoder[2*t+z][2*g] = -F(1, 8) + decoder[2*t+z][2*g+1] = F(3 if z else -3, 16) + need(all(sum(decoder[i][g]*ell[g][j] for g in range(n)) + == F(fix['C'][i][j]) for i in range(n) for j in range(n)), + 'dynamic exact coefficient identity C=R L') + events = [] + + def add(dst, src, q, tag): + if q: + events.append({'op': 'add', 'dst': dst, 'src': src, + 'q': str(q), 'tag': tag}) + + def climb(reg, frame, tag): + events.append({'op': 'climb', 'register': reg, + 'frame': list(frame), 'tag': tag}) + + for t in range(n): + for j in range(n): + add(f'y{t}', f'h{j}', -decoder[t][j], 'comp_prefix') + add(f'y{t}', f'c{j}', -k[t][j], 'K_prefix') + # At depth0 each source pair and its reader pair meet at U_g. + # At depth d>0 source group j visits F(j-d,d+1), including itself. + # Its previous visit F(j-d+1,d) is a subspace of this new arc. + for depth in range(r-1): + for g in range(r): + source = (g+depth) % r + frame = arc[g, depth+1] + for z in range(2): + climb(f'x{2*source+z}', frame, 'source_read_arc') + climb(f'h{2*g+z}', frame, 'mutable_reader_arc') + for z in range(2): + add(f'h{2*g}', f'x{2*source+z}', F(1), 'mutable_read') + add(f'h{2*g+1}', f'x{2*source+z}', F(1 if z == 0 else -1), 'mutable_read') + for i in range(n): + climb(f'x{i}', m.FULL, 'source_full') + climb(f'c{i}', m.FULL, 'K_center_full') + add(f'c{i}', f'x{i}', F(1), 'K_gather') + for j in range(n): + events.append({'op': 'private', 'center': f'c{j}', + 'targets': [[f'y{i}', str(k[i][j])] for i in range(n) if k[i][j]], + 'tag': 'K_private'}) + for i in range(n): + add(f'c{i}', f'x{i}', -F(1), 'K_restore') + for g in range(r): + t = (g-1) % r + for z in range(2): + climb(f'y{2*t+z}', arc[g, r-1], 'target_final_arc') + for channel in range(2): + add(f'y{2*t+z}', f'h{2*g+channel}', + decoder[2*t+z][2*g+channel], 'comp_scatter') + climb(f'y{2*t+z}', tuple(fix['ends'][f'y{2*t+z}']), 'target_cap') + for j in range(n): + climb(f'h{j}', m.FULL, 'reader_restore_full') + for i in range(n): + add(f'h{j}', f'x{i}', -ell[j][i], 'comp_restore') + fix.update(L=[[str(q) for q in row] for row in ell], + R=[[str(q) for q in row] for row in decoder], events=events, + mechanism='mutable cyclic prefix readers; one final delivery') + return fix + + +def conditional_tariffs(): + rows = [] + for r in range(2, 8): + source = [1]*(r-1)+[17-r] + target = [r, 16-r] + helper = [2]+[1]*(r-2)+[17-r] + for L in range(3, 34, 2): + row = b.model(L, source, target, helper, b.N) + rows.append({'r': r, 'L': L, 'm': row['m'], 'q': row['q'], + 'pad': row['pad'], 'source': source, 'target': target, + 'helper': helper, 'R': b.N, 'stock_W': str(row['W']), + 'K_ordinary_roles': b.KC, 'K_private_C': b.KBILL, + 'coverage_deficit': row['D'], + 'rank_histogram': {r: str(n) for r, n in sorted(row['H'].items())}, + 'targets': [dict(b.target_row(row, k), + helper_boundary=b.helper_boundary(row, k)) + for k in map(F, ('.002', '.003', '.005'))]}) + return rows + + +def main(): + cases, controls = [], [] + for r in range(2, 8): + fix = fixture(r) + n = fix['N'] + forward, dual = m.replay(fix), m.replay(fix, True) + need(forward['rank_mass'] == dual['rank_mass'] == 83*n, + 'whole dynamic word rank mass') + need(forward['scalar_primitives_before_real_doubling'] == n*(54*r-1), + 'whole dynamic forward primitive bound') + need(dual['scalar_primitives_before_real_doubling'] == n*(54*r+2), + 'whole dynamic dual primitive bound') + independent = c.matrix_check(fix) + for tag in ('mutable_read', 'comp_prefix', 'comp_scatter', + 'comp_restore', 'K_private', 'source_read_arc', + 'mutable_reader_arc', 'target_final_arc'): + for inverse in (False, True): + try: + m.replay(fix, inverse, tag) + except ValueError as err: + controls.append({'r': r, 'omit': tag, 'dual': inverse, + 'gate': str(err)}) + else: + raise ValueError('meaningful dynamic defect accepted '+tag) + cases.append({'r': r, 'N': n, 'C_rank': n, 'restricted_K_rank': n, + 'ordinary_mutable_readers': n, 'compensation_private_rank': 0, + 'source_path': [1]*(r-1)+[17-r], + 'target_path': [r, 16-r], + 'helper_path': [2]+[1]*(r-2)+[17-r], + 'forward': forward, 'dual': dual, + 'independent_operator_entries': independent, 'fixture': fix}) + tariffs = conditional_tariffs() + out = {'status': 'PASS_ACTUAL_MUTABLE_CYCLIC_H6_READERS_NO_NEW_KAPPA', + 'source_pin': b.PIN, 'cases': cases, 'controls': controls, + 'conditional_full_H6_tariffs': tariffs, + 'limits': 'Actual E8 examples r=2..7,N=4..14. Sources really traverse the declared nested read arcs; targets stayZERO through K and have one final arc visit. Full subfamily K is rankN with private C=17N, so standalone coverage fails for every L. Full-domain tariff assumes an unconstructed common-frame incidence network using N such channels and the unchanged816-center full K. Pure-block couplings, whole H6 geometry, physical allocation, approximate-child precision and outer BIT closure remain unproved. Tariff passing is not a kappa claim.'} + (HERE/'DYNAMIC-CYCLIC-RESULT.json').write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + print(out['status']+' cases=6 controls='+str(len(controls))) + for case in cases: + print('r', case['r'], 'N', case['N'], 'rank', case['forward']['rank_mass'], + 'primitives', case['forward']['scalar_primitives_before_real_doubling'], + case['dual']['scalar_primitives_before_real_doubling']) + for r in (3, 7): + candidates = [row for row in tariffs if row['r'] == r] + for k in ('1/500', '3/1000', '1/200'): + best = max(candidates, + key=lambda row: F(next(t for t in row['targets'] if t['target'] == k)['raw_slack']['lower'])) + t = next(t for t in best['targets'] if t['target'] == k) + print('conditional r', r, 'target', k, 'bestL', best['L'], + 'maxR', t['helper_boundary']['largest_nonnegative_R'], + 'M', t['normalized_moment']['lo']) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/pauli/frozen/e8_cubed.py b/research/h6-partial-frame-networks/pauli/frozen/e8_cubed.py new file mode 100644 index 0000000000..d4444d142f --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/e8_cubed.py @@ -0,0 +1,302 @@ +"""Exact E8^3 norm-four shell, binary fit, and dyadic scalar factorization. + +Coordinates are doubled: roots have squared norm 8 and the norm-four shell +has squared norm 16. All rank calculations are over finite fields; no +floating-point rank or sampled all-pairs assertion is used. +""" +from collections import Counter +from fractions import Fraction +from itertools import combinations, combinations_with_replacement, product +import hashlib +import json +import numpy as np + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def insert_binary(basis, value): + value = int(value) + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + return True + return False + + +def inverse_binary(matrix): + size = len(matrix) + work = np.concatenate((matrix.copy(), np.eye(size, dtype=np.uint8)), axis=1) + for col in range(size): + choices = np.flatnonzero(work[col:, col]) + require(len(choices) > 0, 'Invertible binary Gram matrix') + pivot = col + int(choices[0]) + work[[col, pivot]] = work[[pivot, col]] + for row in range(size): + if row != col and work[row, col]: + work[row] ^= work[col] + return work[:, size:] + + +def symplectic_transform(matrix): + size = len(matrix) + require(size % 2 == 0 and np.array_equal(matrix, matrix.T) + and not np.diag(matrix).any(), 'Alternating binary form') + transform = np.eye(size, dtype=np.uint8) + work = matrix.copy() + for first in range(0, size, 2): + choices = np.argwhere(work[first:, first:]) + require(len(choices) > 0, 'Nondegenerate alternating form') + a, b = (int(value) + first for value in choices[0]) + for current, target in ((a, first), (b if b != first else a, first + 1)): + work[[current, target]] = work[[target, current]] + work[:, [current, target]] = work[:, [target, current]] + transform[[current, target]] = transform[[target, current]] + for row in range(first + 2, size): + left, right = int(work[row, first + 1]), int(work[row, first]) + if left: + transform[row] ^= transform[first] + if right: + transform[row] ^= transform[first + 1] + work = (transform @ matrix @ transform.T) & 1 + target = np.zeros_like(matrix) + for first in range(0, size, 2): + target[first, first + 1] = target[first + 1, first] = 1 + require(np.array_equal(work, target), 'Symplectic basis identity') + return transform + + +def canonical_lines(vectors): + array = np.asarray(vectors, dtype=np.int16) + first = np.argmax(array != 0, axis=1) + signs = np.where(array[np.arange(len(array)), first] > 0, 1, -1) + return np.unique(array * signs[:, None], axis=0).astype(np.int16) + + +def e8_shells(): + roots, fourth = [], [] + for positions in combinations(range(8), 2): + for signs in product((-2, 2), repeat=2): + row = np.zeros(8, dtype=np.int16) + row[list(positions)] = signs + roots.append(row) + for signs in product((-1, 1), repeat=8): + if sum(signs) % 4 == 0: + roots.append(np.array(signs, dtype=np.int16)) + for coordinate in range(8): + for sign in (-4, 4): + row = np.zeros(8, dtype=np.int16) + row[coordinate] = sign + fourth.append(row) + for positions in combinations(range(8), 4): + for signs in product((-2, 2), repeat=4): + row = np.zeros(8, dtype=np.int16) + row[list(positions)] = signs + fourth.append(row) + for coordinate in range(8): + for signs in product((-1, 1), repeat=8): + row = np.array(signs, dtype=np.int16) + row[coordinate] *= 3 + if int(row.sum()) % 4 == 0: + fourth.append(row) + require(len(roots) == 240 and len(fourth) == 2160, 'E8 shell vector counts') + roots, fourth = canonical_lines(roots), canonical_lines(fourth) + require(roots.shape == (120, 8) and fourth.shape == (1080, 8), 'E8 line counts') + for rows, norm in ((roots, 8), (fourth, 16)): + require(np.all((rows * rows).sum(axis=1) == norm), 'Exact E8 shell norms') + require(np.all(rows.sum(axis=1) % 4 == 0), 'Doubled E8 parity condition') + require(np.all((rows % 2) == (rows[:, :1] % 2)), 'Doubled E8 coordinate parity') + return roots, fourth + + +def construct_shell(): + roots, fourth = e8_shells() + pieces, profiles = [], [] + for block in range(3): + rows = np.zeros((1080, 24), dtype=np.int16) + rows[:, 8 * block:8 * (block + 1)] = fourth + pieces.append(rows) + profiles.extend([1 << block] * len(rows)) + for first, second in combinations(range(3), 2): + rows = np.zeros((28800, 24), dtype=np.int16) + rows[:, 8 * first:8 * (first + 1)] = np.repeat(roots, 240, axis=0) + rows[:, 8 * second:8 * (second + 1)] = ( + np.tile(np.repeat(roots, 2, axis=0), (120, 1)) + * np.tile([1, -1], 14400)[:, None]) + pieces.append(rows) + profiles.extend([(1 << first) | (1 << second)] * len(rows)) + rows = np.concatenate(pieces) + require(rows.shape == (89640, 24), 'E8 cubed norm-four line count') + require(np.all((rows * rows).sum(axis=1) == 16), 'E8 cubed shell norms') + require(len({row.tobytes() for row in rows}) == len(rows), 'Distinct canonical lines') + first = np.argmax(rows != 0, axis=1) + require(np.all(rows[np.arange(len(rows)), first] > 0), 'Canonical antipodal orientation') + return roots, fourth, rows, np.array(profiles, dtype=np.uint8) + + +def binary_labels(roots, ports): + blocks = ports.shape[1] // 8 + dimension = 8 * blocks + 1 + integer_gram = roots @ roots.T + require(not (integer_gram % 4).any(), 'Integral E8 lattice pairings') + gram = ((integer_gram // 4) & 1).astype(np.uint8) + work, available, selected = gram.copy(), list(range(120)), [] + while work[np.ix_(available, available)].any(): + a, b = np.argwhere(work[np.ix_(available, available)])[0] + a, b = available[int(a)], available[int(b)] + selected.extend((a, b)) + left, right = work[a].copy(), work[b].copy() + work ^= np.outer(left, right) ^ np.outer(right, left) + available.remove(a) + available.remove(b) + require(len(selected) == 8, 'E8 mod-two rank eight') + basis = roots[selected] + inverse = inverse_binary(gram[np.ix_(selected, selected)]) + coordinates = np.zeros((len(ports), dimension - 1), dtype=np.uint8) + form = np.zeros((dimension - 1, dimension - 1), dtype=np.uint8) + for block in range(blocks): + pairings = ports[:, 8 * block:8 * (block + 1)] @ basis.T + require(not (pairings % 4).any(), 'Integral shell-basis pairings') + coordinates[:, 8 * block:8 * (block + 1)] = (pairings // 4) & 1 + form[8 * block:8 * (block + 1), 8 * block:8 * (block + 1)] = inverse + even_gram = np.ones((dimension - 1, dimension - 1), dtype=np.uint8) ^ np.eye(dimension - 1, dtype=np.uint8) + change = (inverse_binary(symplectic_transform(form)) + @ symplectic_transform(even_gram)) & 1 + require(np.array_equal((change @ even_gram @ change.T) & 1, form), + 'Standard-dot even-space isometry') + even_basis = np.concatenate((np.eye(dimension - 1, dtype=np.uint8), + np.ones((dimension - 1, 1), dtype=np.uint8)), axis=1) + labels = ((coordinates @ change @ even_basis) & 1) ^ 1 + require(np.all(labels.sum(axis=1) % 2 == 1), 'Odd standard-dot labels') + packed = labels.astype(np.uint32) @ (1 << np.arange(dimension, dtype=np.uint32)) + spanning, witnesses = {}, [] + for index, value in enumerate(packed): + if insert_binary(spanning, value): + witnesses.append(index) + require(len(spanning) == dimension, 'Full binary label span') + samples = np.unique(np.concatenate((witnesses, np.linspace(0, len(ports) - 1, 32, dtype=int)))) + for index in samples: + dots = ports @ ports[index] + require(not (dots % 4).any(), 'Integral shell pairings') + require(np.array_equal((labels @ labels[index]) & 1, 1 ^ ((dots // 4) & 1)), + 'Exact label identity on additional diagnostic rows') + return labels, packed, dict(dimension=dimension, root_basis_indices=selected, + root_basis_vectors=basis.tolist(), alternating_gram=form.tolist(), + standard_dot_coordinate_map=((change @ even_basis) & 1).tolist(), + span_witnesses=witnesses, diagnostic_rows=samples.tolist(), + identity='p(u) dot p(v) = 1 + (u dot v / 4) mod 2', + universal_proof=f'The eight E8 basis roots have an odd integral Gram determinant. In lattice pairing coordinates its rational inverse reduces to the displayed binary inverse. {"Three" if blocks == 3 else "Two"} orthogonal blocks give the alternating rank-{dimension - 1} form; the verified even-space isometry and the orthogonal all-ones vector realize it by the standard dot product in dimension {dimension}.') + + +def modular_rank_witnesses(rows, prime=101): + basis, selected = {}, [] + for index, raw in enumerate(rows): + row = np.asarray(raw, dtype=np.int64).copy() % prime + for pivot in sorted(basis): + row = (row - row[pivot] * basis[pivot]) % prime + nonzero = np.flatnonzero(row) + if not len(nonzero): + continue + pivot = int(nonzero[0]) + basis[pivot] = row * pow(int(row[pivot]), -1, prime) % prime + selected.append(index) + if len(basis) == rows.shape[1]: + break + return selected + + +def real_rank(roots, fourth): + witnesses = {} + for name, rows, degree, expected in ( + ('pure_cubics', fourth, 3, 120), + ('root_quadratics', roots, 2, 36), ('root_linears', roots, 1, 8)): + monomials = list(combinations_with_replacement(range(8), degree)) + features = np.stack([np.prod(rows[:, monomial].astype(np.int64), axis=1) + for monomial in monomials], axis=1) + selected = modular_rank_witnesses(features) + require(len(selected) == expected, f'Exact rational feature rank: {name}') + witnesses[name] = dict(prime=101, rank=expected, independent_rows=selected) + trace_norm = (Fraction(1) + Fraction(23, 3)) / 256 + correction_eigenvalue = 1 - 64 * trace_norm + require(trace_norm == Fraction(13, 384) and correction_eigenvalue == Fraction(-7, 6), + 'Nonzero trace-correction eigenvalue') + return dict(real_kernel_rank=2088, pure_cubic_features=360, mixed_cubic_features=1728, + omitted_three_block_features=512, finite_rank_witnesses=witnesses, + trace_correction_eigenvalue=str(correction_eigenvalue), signature=[2064, 24], + proof='The pure norm-four sectors make all 3 times 120 pure cubics independent. On each root-pair sector, changing one block sign separates the two mixed parities; ranks 36 and 8 give 288 independent features per ordered block pair. Thus the 2088 retained cubic columns are independent. Let D contain cubic multinomial coefficients and represent u_i as (sum_j u_i*u_j^2)/16. The coefficient matrix is (D-64 L L^T)/3072, with L^T D^-1 L=(13/384)I_24. Its rank-24 correction has nonzero eigenvalue -7/6, proving rank 2088 and the displayed signature.') + + +def support_orbit(ports, packed, name, coordinates=None): + if coordinates is not None: + values = np.prod(ports[:, coordinates].astype(np.int32), axis=1) + else: + value = ports[:, 0].astype(np.int32) + quotient = (value ** 3 - value) // 3 + values = 5 * value - quotient if name == 'unary_f' else quotient - value + support = np.flatnonzero(values) + basis, witnesses = {}, [] + for index in support: + if insert_binary(basis, packed[index]): + witnesses.append(int(index)) + return dict(name=name, representative_coordinates=list(coordinates) if coordinates else [0], + support_size=len(support), binary_span=len(basis), independent_ports=witnesses) + + +def factorization(ports, packed): + orbits = [support_orbit(ports, packed, name, coordinates) for name, coordinates in ( + ('pure_cube', (0, 0, 0)), ('pure_repeated', (0, 0, 1)), + ('pure_distinct', (0, 1, 2)), ('mixed_repeated', (0, 0, 8)), + ('mixed_distinct', (0, 1, 8)), ('unary_f', None), ('unary_g', None))] + require([orbit['binary_span'] for orbit in orbits] == [25, 25, 25, 17, 17, 25, 25], + 'Complete binary support spans for each center orbit') + for left, right in product(range(-4, 5), repeat=2): + q_left, q_right = (left ** 3 - left) // 3, (right ** 3 - right) // 3 + require(left ** 3 * right ** 3 - 64 * left * right == + 3 * (-(5 * left - q_left) * (5 * right - q_right) + + 4 * (q_left - left) * (q_right - right)), + 'Dyadic unary factorization identity') + monomials = [indices for indices in combinations_with_replacement(range(24), 3) + if len({index // 8 for index in indices}) <= 2] + counts = Counter() + for indices in monomials: + blocks = len({index // 8 for index in indices}) + distinct = len(set(indices)) + counts[(blocks, distinct)] += 1 + require(dict(counts) == {(1, 1): 24, (1, 2): 168, (1, 3): 168, + (2, 2): 384, (2, 3): 1344}, 'Cubic feature orbit counts') + return dict(center_count=2112, center_width_histogram={'25': 384, '17': 1728}, + center_bill=38976, literal_cubic_only_bill=38376, + literal_cubic_only_bill_scope='Omits the linear correction; not a certified factorization bill.', + support_orbits=orbits, + dyadic_unary_identity='q(u)=(u^3-u)/3; (u^3*v^3-64*u*v)/3072 = (-(5*u-q(u))*(5*v-q(v))+4*(q(u)-u)*(q(v)-v))/1024', + diagonal_coefficients={'unary_f': '-1/1024', 'unary_g': '1/256', + 'repeated_cubic': '1/1024', 'distinct_cubic': '1/512'}, + proof='Expand (u dot v)^3. All three-block monomials vanish on this shell. Keep the 168 pure repeated, 168 pure distinct, 384 mixed repeated, and 1344 mixed distinct monomials; replace each of the 24 pure-cube plus linear terms by the two displayed unary centers. All coefficients are dyadic. The same feature supports occur on encoder and decoder sides because the factorization is symmetric and diagonal. Block and coordinate permutations preserve E8^3 and induce invertible binary label changes, so the seven full-support orbit checks establish all 2112 center widths.', + scope='Exact scalar fitting kernel and symmetric dyadic factorization with binary support bill. A finite recursive word, helper exits, scheduling, and a new kappa are not supplied by this certificate.') + + +def certify_e8_cubed(): + roots, fourth, ports, profiles = construct_shell() + _, packed, fitting = binary_labels(roots, ports) + values = {str(t): str(Fraction(t ** 3 - 4 * t, 48)) for t in range(-4, 5)} + require(values['4'] == '1' and all(values[str(t)] == '0' for t in (-2, 0, 2)), + 'Scalar kernel diagonal and even off-diagonal zeros') + return dict(status='PASS_EXACT_E8_CUBED_SCALAR_FACTORIZATION', + lattice='E8 cubed', doubled_coordinate_scale=2, norm_four_lines=89640, + norm_four_vectors=179280, e8_root_lines=120, e8_norm_four_lines=1080, + profile_counts={str(key): value for key, value in sorted(Counter(map(int, profiles)).items())}, + ports_sha256=hashlib.sha256(ports.astype(' pivot and (basis[higher] >> pivot) & 1: + basis[higher] ^= basis[pivot] + canonical = tuple(basis[pivot] for pivot in sorted(basis)) + require(len(canonical) == 15, 'Every Pauli partner support has dimension15') + partners.append(canonical) + frames[canonical] += 1 + require(len(set(partners)) == 1, 'All eight coordinate partners share one binary frame') + gram_basis = {} + for left in partners[0]: + gram_row = sum((((left & right).bit_count() & 1) << index) + for index, right in enumerate(partners[0])) + e8.insert_binary(gram_basis, gram_row) + require(len(gram_basis) == 13, 'Pauli support frame has a two-dimensional radical') + groups.append(dict(linear_block=first, quadratic_block=second, + pauli_shift_character=[shift, character], binary_frame=list(partners[0]), + restricted_dot_rank=13, radical_dimension=2)) + require(len(frames) == 70 and set(frames.values()) == {8}, 'Exactly 70 shared Pauli frames') + return dict(distinct_width15_frames=70, centers_per_width15_frame=8, + full_width17_frame_centers=256, restricted_width15_dot_rank=13, + width15_radical_dimension=2, groups=groups, + scope='Exact binary support subspaces of the two-block Pauli factorization. The width15 subspaces are degenerate (restricted dot rank13), so any helper theorem must handle those subspaces. Sharing a frame nominates batches; no helper schedule or routing cost is inferred.') + + +def section_rank(roots, fourth, blocks): + baseline = e8.real_rank(roots, fourth) + dimension = 8 * blocks + trace_norm = Fraction(dimension + 2, 768) + eigenvalue = 1 - 64 * trace_norm + expected = 120 * blocks + 288 * blocks * (blocks - 1) + require(eigenvalue != 0, 'Nondegenerate real coefficient form') + return dict(real_kernel_rank=expected, pure_cubic_features=120 * blocks, + mixed_cubic_features=288 * blocks * (blocks - 1), + finite_rank_witnesses=baseline['finite_rank_witnesses'], + trace_correction_eigenvalue=str(eigenvalue), + signature=[expected - dimension, dimension], + proof='Pure sectors and opposite relative signs separate independent cubic spaces, using the displayed finite rank witnesses 120,36,8. For the retained cubic feature matrix F, K=F(D-64 L L^T)F^T/3072. Since the shell norm is16 in doubled coordinates, u_i=sum_j u_i*u_j^2/16, and L^T D^-1 L=((8*blocks+2)/768)I. The nonzero displayed correction eigenvalue proves the exact real rank.') + + +def walsh_sections(): + hadamard = np.array([[1, 1], [1, -1]], dtype=np.int32) + require(np.array_equal(hadamard @ hadamard, 2 * np.eye(2, dtype=np.int32)), + 'Relative-sign Walsh inverse is H/2') + return dict(matrix=hadamard.tolist(), inverse_denominator=2, + same_label_identity='p(a,b)=p(a,-b), since all lattice pairings agree modulo two.', + three_block_sectors=3, ports_per_three_block_sector=29880, + real_rank_per_three_block_sector=696, + two_block_sectors=2, ports_per_two_block_sector=15480, + real_rank_per_two_block_sector=408, + pair_kernel_after_transform='For two AB ports in the odd-A sector, s_A*(s_A^2+3*s_B^2-4)/24, where s_A and s_B are ordinary root inner products.', + proof='Every retained cubic or linear feature is odd in exactly one block. Transform each present relative-sign pair (a,b),(a,-b) by H on inputs and H/2 on outputs. This same-label similarity preserves the binary labels and unit diagonal, and separates the odd-block characters. Pure ports already have one character. At a fixed root a, the same-sector pair kernel is s_B^2/4, whose real rank is36 by the exact root-quadratic witness; this is not an eight-dimensional E8 frame replication.', + scope='An exact free change of basis within equal-label ports. It does not by itself supply improved helper exits or a complete recursive word.') + + +def certify_sections(): + roots, fourth, full, profiles = e8.construct_shell() + results = [] + for blocks in (2, 3): + ids = np.flatnonzero((profiles & (7 ^ ((1 << blocks) - 1))) == 0) + ports = full[ids, :8 * blocks] + expected = 1080 * blocks + 28800 * (blocks * (blocks - 1) // 2) + require(len(ports) == expected, 'Exact E8 section shell count') + _, packed, fitting = e8.binary_labels(roots, ports) + coordinate_factor = fano_factorization(ports, packed, blocks) + frames = support_frames(ports, packed) if blocks == 2 else None + results.append(dict(blocks=blocks, port_count=len(ports), fitting=fitting, + real_rank=section_rank(roots, fourth, blocks), + coordinate_factorization=coordinate_factor, + operator_factorization=operator_factorization(ports, packed, blocks, coordinate_factor), + shared_support_frames=frames)) + return dict(status='PASS_EXACT_E8_SECTION_FACTORIZATIONS', cases=results, + relative_sign_walsh=walsh_sections()) + + +if __name__ == '__main__': + print(json.dumps(certify_sections(), indent=2, sort_keys=True)) diff --git a/research/h6-partial-frame-networks/pauli/frozen/mixed_rectangle.py b/research/h6-partial-frame-networks/pauli/frozen/mixed_rectangle.py new file mode 100644 index 0000000000..73d430a02a --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/mixed_rectangle.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 +"""Actual four-port H6 mixed-source compensation: complete all-input word. + +The physical Clifford/adapter compiler is inherited, not executed here. +All ordinary frames, arbitrary dirt and both chronological orientations +are checked exactly. This is a bounded construction, not a full H6 supplier. +""" +from fractions import Fraction as F +from itertools import combinations, product +from pathlib import Path +from collections import Counter +import hashlib +import json +import copy + +HERE = Path(__file__).resolve().parent +H = 17 +FULL = tuple(1 << i for i in reversed(range(H))) + + +def need(ok, label): + if not ok: raise ValueError(label) + + +def basis(words): + piv = {} + for v in words: + for k in sorted(piv, reverse=True): + if v >> k & 1: v ^= piv[k] + if v: + k = v.bit_length()-1 + for j in list(piv): + if piv[j] >> k & 1: piv[j] ^= v + piv[k] = v + return tuple(piv[k] for k in sorted(piv, reverse=True)) + + +def included(a,b): return len(basis(a+b)) == len(b) + + +def perp(v): + k = (v & -v).bit_length()-1 + return basis((1 << i) ^ ((1 << k) if v >> i & 1 else 0) for i in range(H) if i != k) + + +def mm(a,b): + return [xor(b[j] for j in range(len(b)) if row >> j & 1) for row in a] + + +def xor(xs): + z = 0 + for x in xs: z ^= x + return z + + +def tr(a,n): return [sum(((row >> j) & 1) << i for i,row in enumerate(a)) for j in range(n)] + + +def inv(a): + n = len(a); work = [row | (1 << (n+i)) for i,row in enumerate(a)] + for j in range(n): + p = next(i for i in range(j,n) if work[i] >> j & 1) + work[j],work[p] = work[p],work[j] + for i in range(n): + if i != j and work[i] >> j & 1: work[i] ^= work[j] + need([r & ((1<> n for r in work] + + +def cong(t,m): return mm(mm(t,m),tr(t,len(t))) + + +def symp(m): + n = len(m); t = [1<> b & 1) + for cur,dst in ((a,k),(b if b != k else a,k+1)): + t[cur],t[dst] = t[dst],t[cur] + work = cong(t,m) + for i in range(k+2,n): + left,right = (work[i] >> (k+1)) & 1,(work[i] >> k) & 1 + if left: t[i] ^= t[k] + if right: t[i] ^= t[k+1] + work = cong(t,m) + need(work == [1 << (i^1) for i in range(n)], "symplectic congruence") + return t + + +def canonical_roots(): + roots = [] + for i,j in combinations(range(8),2): + for x,y in product((-2,2),repeat=2): + a = [0]*8; a[i],a[j] = x,y; roots.append(tuple(a)) + roots.extend(a for a in product((-1,1),repeat=8) if sum(a) % 4 == 0) + return sorted({a if next(x for x in a if x) > 0 else tuple(-x for x in a) for a in roots}) + + +def dot(a,b): + z = sum(x*y for x,y in zip(a,b)) + need(z % 4 == 0, "integral E8 pairing") + return z//4 + + +def actual_labels(ports): + # Source-faithful bit implementation of e8_cubed.py::binary_labels. + roots = canonical_roots() + gram = [sum((dot(a,b)&1)<> b & 1 for a in av for b in av): + a,b = next((a,b) for a in av for b in av if work[a] >> b & 1) + sel.extend((a,b)); left,right = work[a],work[b] + work = [r ^ (right if left >> i & 1 else 0) ^ (left if right >> i & 1 else 0) for i,r in enumerate(work)] + av.remove(a); av.remove(b) + need(len(sel) == 8, "binary E8 basis size") + qq = [roots[i] for i in sel] + small = [sum(((gram[i]>>j)&1)<> c & 1 for a in available for c in available): + a,c = next((a,c) for a in available for c in available if work[a] >> c & 1) + selected.extend((a,c)) + left, right = work[a], work[c] + work = [row ^ (right if left >> i & 1 else 0) + ^ (left if right >> i & 1 else 0) + for i,row in enumerate(work)] + available.remove(a) + available.remove(c) + small = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in selected] + inverse = m.inv(small) + form = inverse+[row << 8 for row in inverse] + even = [((1 << 16)-1) ^ (1 << i) for i in range(16)] + change = m.mm(m.inv(m.symp(form)), m.symp(even)) + need(m.cong(change, even) == form, 'pinned standard-dot isometry') + mapping = m.mm(change, [(1 << i)|(1 << 16) for i in range(16)]) + coordinates = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in range(120)] + return [[((1 << 17)-1) ^ m.mm([x|(y << 8)], mapping)[0] + for y in coordinates] for x in coordinates] + + +def orthogonal_involution(roots): + position = {a:i for i,a in enumerate(roots)} + mates = [] + for a in roots: + c = list(a) + if all(x % 2 == 0 for x in a): + nonzero = [i for i,x in enumerate(a) if x] + c[nonzero[1]] *= -1 + else: + for i in range(4,8): + c[i] *= -1 + mates.append(position[tuple(c)]) + need(all(i != j and mates[j] == i and m.dot(roots[i], roots[j]) == 0 + for i,j in enumerate(mates)), 'explicit120-root orthogonal involution') + pairs = [(i,j) for i,j in enumerate(mates) if i < j] + need(len(pairs) == 60, 'sixty orthogonal b-pairs') + return pairs + + +def tiling(): + roots = m.canonical_roots() + need(sorted(i for row in TRIPLES for i in row) == list(range(120)), + 'explicit disjoint acute-triple partition') + signs = [] + for row in TRIPLES: + sigma = [1]+[m.dot(roots[row[0]], roots[i]) for i in row[1:]] + need(all(abs(x) == 1 for x in sigma), 'triple gauge signs') + need(all(sigma[i]*sigma[j]*m.dot(roots[row[i]], roots[row[j]]) == 1 + for i in range(3) for j in range(i)), 'acute triple after gauge') + signs.append(sigma) + pairs = orthogonal_involution(roots) + packed = packed_root_pairs(roots) + assigned = set() + examples = [] + coefficient_census = Counter() + for ti, aa in enumerate(TRIPLES): + sigma = signs[ti] + for bi, bb in enumerate(pairs): + labels = [packed[a][bb[z]] for a in aa for z in range(2)] + planes = [m.basis(labels[2*g:2*g+2]) for g in range(3)] + arcs = [m.basis(planes[g]+planes[(g+1)%3]) for g in range(3)] + need(all(len(x) == 2 for x in planes) and all(len(x) == 3 for x in arcs), + 'actual r3 module source and final reader frames') + need(all(m.included(arcs[g], m.perp(labels[2*((g-1)%3)+z])) + for g in range(3) for z in range(2)), 'actual module final target caps') + need(all(m.included(planes[j], arcs[(j-1)%3]) for j in range(3)), + 'actual mutable source nested visits') + if ti == 0 and bi < 2: + examples.append({'triple': ti, 'b_pair': bi, 'labels': labels, + 'planes': [list(x) for x in planes], + 'final_arcs': [list(x) for x in arcs]}) + for epsilon in (-1,1): + ports = [] + indices = [] + for group,a in enumerate(aa): + sign = epsilon*sigma[group] + for bj in bb: + ports.append(roots[a]+tuple(sign*x for x in roots[bj])) + indices.append(2160+240*a+2*bj+int(sign < 0)) + need(not (assigned & set(indices)), 'disjoint module source/target IDs') + assigned.update(indices) + for i in range(6): + for j in range(6): + t = m.dot(ports[i], ports[j]) + cij = F(int(i == j))-F(t**3-4*t,48) + expected = F(0) if i//2 == j//2 else F( + sigma[i//2]*sigma[j//2]*(-5 if i%2 == j%2 else 1),16) + need(cij == expected, 'literal actual coefficient equals gauged cyclic module') + need((labels[i]&labels[j]).bit_count()%2 == (1+t)%2, + 'literal actual source address parity') + if cij: + coefficient_census[abs(cij)] += 1 + need(assigned == set(range(2160,30960)), 'all28800 root-product ports tiled exactly once') + need(coefficient_census == {F(1,16):57600, F(5,16):57600}, + 'exact115200 compensated ordered pairs') + return roots, pairs, signs, examples, coefficient_census + + +def actual_edge_completion_model(L, residual_edges): + row = b.model(L, [16], [16], [17], 0) + census = Counter(row['H']) + # Replace residual16 source/target paths only for the28800 tiled ports. + for path in ([1,1,14], [3,13]): + census[16] -= L*28800 + for rank in path: + census[rank] += L*28800 + for count,path in ((28800,[2,1,14]), (residual_edges,[1,15,1])): + for rank in path: + census[rank] += L*count + roles = 28800+residual_edges + if row['pad']: + for rank in b.oracle.partition(row['pad'], row['cap']): + census[rank] += F(L*roles, row['q']) + row.update(H=census, W=row['W']+F(L*roles,row['q']), R=roles) + need(sum(rank*n for rank,n in census.items()) == row['m']*row['W']-row['D'], + 'complete tiled-plus-edge full H6 histogram') + return row + + +def main(): + roots, pairs, signs, examples, coefficient_census = tiling() + path = 'research/h6-independent-audit/walsh/results.json' + raw = subprocess.check_output(['git','show',b.PIN+':'+path],cwd=b.REPO) + inherited = json.loads(raw) + need(inherited['compensation_nonzeros'] == 480337920 + and inherited['exceptional_abs_t_3_pairs'] == 3363840, + 'pinned all-pair support receipt') + residual_exceptional = 3363840-57600 + residual_unit = 480337920-3363840-57600 + residual = residual_exceptional+residual_unit + need(residual == 480222720, 'exact residual ordered support count') + # An actual complete local word exists by using initial-line residual + # edge readers and delivering them at final caps after module delivery. + component_comp = 4800*396+24*residual_unit+30*residual_exceptional + forward = 247217040+component_comp + dual = 247219488+component_comp + old = 247217040+24*(480337920-3363840)+30*3363840 + need(old-forward == 1209600, 'actual component primitive saving') + row = actual_edge_completion_model(5,residual) + price = b.target_row(row,F('.002')) + need(price['verdict'].startswith('FAILS'), 'complete edge completion fails target') + # C-D=(I-D)-K. Every actual r3 K block is invertible; pure2160 I + # gives rank(I-D)=30960. Hence rank residual >=30960-816. + private_floor = 30960-816 + need(13872+private_floor > 30960, 'actual module private residual coverage fails all L') + # Even if each module's coefficients are redesigned arbitrarily, keeping + # zero own-group2x2 blocks forces rank(I-D_module)>=2. The most favorable + # disjoint-module rank floor is2*4800+2160=11760, residual>=10944. + redesigned_A = 2*4800+2160 + redesigned_residual = redesigned_A-816 + need(redesigned_residual == 10944, 'redesigned disjoint-module residual rank floor') + # Grant free residual banks and ideal rank1 private descents. Active data + # pressure alone/NL >32*.002*log L. Its excess against D is bounded by + # min_(L>0) [.064 log L+1/L] -(1-(13872+10944)/30960). + constant = F(8,125) + tail = constant*(1+b.oracle.log_interval(1/constant)[0])-(1-F(13872+10944,30960)) + need(tail > 0, 'all positive L redesigned private residual fails .002') + out = {'status':'PASS_ACTUAL_FULL_ROOT_PRODUCT_DYNAMIC_TILING_AND_PAID_RESIDUAL_NO_NEW_KAPPA', + 'source_pin':b.PIN,'inherited_support_source':path, + 'inherited_support_sha256':hashlib.sha256(raw).hexdigest(), + 'canonical_roots':roots,'a_triples':TRIPLES,'triple_gauge_signs':signs, + 'b_orthogonal_involution_pairs':pairs,'module_count':4800, + 'module_rule':'For each acute a-triple, orthogonal b-pair, epsilon=+-1, port(group,z)=(a_group,epsilon*sigma_group*b_z). Source product ID2160+240*a+2*b+int(sign<0).', + 'actual_tiled_ports':28800,'untiled_ports':{'indices':[0,2159], 'meaning':'Both1080-port pure norm4 blocks; complete interval0<=i<2160.'}, + 'actual_module_frame_cases':2400,'frame_examples':examples, + 'covered_ordered_nonzero_entries':115200, + 'covered_unit_entries':57600,'covered_exceptional_entries':57600, + 'uncovered_ordered_nonzero_entries':residual, + 'uncovered_unit_entries':residual_unit, + 'uncovered_exceptional_entries':residual_exceptional, + 'exact_uncovered_set':'All ordered pairs(t,s) with actual odd Gram t_ts and with t,s not belonging to the same six-port module above. Every pair involving a pure port is outside the modules; within-module C equals D exactly.', + 'actual_full_completion':{'module_readers':28800,'residual_edge_readers':residual, + 'ordinary_K_centres':816,'K_private_C':13872, + 'total_ordinary_compensation_roles':28800+residual, + 'component_primitives_forward':forward, + 'component_primitives_dual':dual, + 'component_saving_against_full_edge_word':old-forward, + 'L5_stock_W':str(row['W']),'L5_q_replica_banks':5*(row['R']+816), + 'L5_complete_histogram':{r:str(n) for r,n in sorted(row['H'].items())}, + 'L5_target_002':price, + 'word_contract':'AtZERO precompensate K,module and residual dirt. Load every residual edge helper at its original source line before module source climbs. Execute changing module gathers on disjoint nested arcs; sources reachFULL. Run unchanged816-centre K while targetsZERO. Deliver modules at their rank3 arcs, then targets finish caps. Deliver each residual edge helper at its rank16 target cap. Restore all compensation helpers atFULL. Same-order dual has separate K private episodes. Full billion-event stream is mathematically specified/counted, not materialized.'}, + 'actual_private_residual':{'rank_I_minus_D':30960,'rank_lower':private_floor, + 'best_private_rank_floor':private_floor, + 'total_private_C_lower':13872+private_floor, + 'all_L_coverage_deficit_upper':'-30960-13056*L'}, + 'redesigned_disjoint_r3_private_residual':{'rank_I_minus_D_lower':redesigned_A, + 'rank_residual_lower':redesigned_residual, + 'total_private_C_lower':13872+redesigned_residual, + 'all_positive_L_active_data_gap_lower':str(tail), + 'assumptions':'Arbitrary weights per disjoint6-port r3 module, no within-own-group coefficient, D=0 on pure ports. All residual dependence returns through private episodes, each granted ideal rank1 and free ordinary banks.'}, + 'controls':{'tile_signs_required':any(x<0 for row in signs for x in row), + 'b_mates_are_distinct':all(i!=j for i,j in pairs), + 'pure_ports_not_claimed_tiled':len(roots)*240 == 28800, + 'dropping_residual_changes_operator':residual>0}, + 'scope':'Actual disjoint r3 tiling with exact residual set, actual edge-helper completion and scoped private-residual failures. Overlapping/composed dynamic modules, mutable residual networks, changed source/target schedules and different centre interfaces remain open. No new kappa or full physical/approximate supplier admission.'} + (HERE/'MODULE-TILING-RESULT.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']+' modules=4800 root_ports=28800 pure_ports=2160 residual_edges='+str(residual)) + print('actual private residual rank>=',private_floor,'Ctotal>=',13872+private_floor) + print('redesigned private residual rank>=',redesigned_residual,'active gap lower',b.dec(tail)) + print('full edge completion primitives',forward,dual,'L5 M',price['normalized_moment']['lo']) + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/pauli/frozen/partial_pauli.py b/research/h6-partial-frame-networks/pauli/frozen/partial_pauli.py new file mode 100644 index 0000000000..04562b96bf --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/partial_pauli.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +"""Actual rank15 partial gathers for one eight-centre H6 Pauli group. + +Both ZERO and radical output frames, arbitrary dirty centres, exact private +contracts, complete source/target path differentials and conditional sharing. +""" +from collections import Counter +from fractions import Fraction as F +from pathlib import Path +import importlib.util +import json + +HERE = Path(__file__).resolve().parent + + +def load(name, file): + spec = importlib.util.spec_from_file_location(name,HERE/file) + out = importlib.util.module_from_spec(spec) + spec.loader.exec_module(out) + return out + + +t = load('pauli_tiling_fit','module_tiling.py') +m,b,need = t.m,t.b,t.need +ranker = load('pauli_exact_rank','partial_filter.py').rank + + +def setup(): + roots = m.canonical_roots() + packed = t.packed_root_pairs(roots) + q = [sum((1 if not(j&1) else -1)*x*x for j,x in enumerate(a)) for a in roots] + selected = [j for j,x in enumerate(q) if x] + need(len(selected)==24 and {q[j] for j in selected}=={-8,8},'actual24-line Pauli support') + support = [(i,j) for i in range(120) for j in selected] + U = m.basis(packed[i][j] for i,j in support) + radical = m.basis(w for w in range(1<<17) + if all(not((w&u).bit_count()%2) for u in U)) + need(len(U)==15 and len(radical)==2 and m.included(radical,U), + 'actual degenerate rank15 frame and radical2') + need(all(m.included(radical,m.perp(packed[i][j])) for i,j in support), + 'common radical scatter frame lies in every supported cap') + features = [[roots[i][c]*q[j] for c in range(8)] for i,j in support] + for c in range(8): + census = Counter(abs(row[c]) for row in features if row[c]) + need(census=={8:1536,16:336},'half-signed actual feature incidence census') + need(ranker([roots[i] for i in range(120)])==8,'eight actual linear feature dimensions') + # A small actual diagnostic has a full rank15 frame witness, all eight + # feature columns, and two zero-feature ports. It is not the full matrix. + chosen=[]; span=() + for i,j in support: + grown=m.basis(span+(packed[i][j],)) + if len(grown)>len(span):chosen.append((i,j));span=grown + if len(span)==15:break + linears=[] + for i in range(120): + if ranker([roots[j] for j in linears]+[roots[i]])>len(linears):linears.append(i) + if len(linears)==8:break + chosen+= [(i,selected[0]) for i in linears] + chosen+= [(105,j) for j in selected[:2]] + chosen+= [(0,j) for j in range(120) if not q[j]][:2] + chosen=list(dict.fromkeys(chosen)) + return roots,packed,q,support,U,radical,chosen + + +def fixture(roots,packed,q,U,W,chosen): + n=len(chosen) + E=[[F(roots[i][c]*q[j]) for c in range(8)] for i,j in chosen] + labels=[packed[i][j] for i,j in chosen] + K=[[sum(E[i][c]*E[j][c] for c in range(8))/8192 + for j in range(n)] for i in range(n)] + starts={f'x{i}':m.basis([labels[i]]) for i in range(n)} + starts.update({f'y{i}':() for i in range(n)}) + starts.update({f'c{c}':() for c in range(8)}) + ends={a:m.FULL for a in starts} + ends.update({f'y{i}':m.perp(labels[i]) for i in range(n)}) + events=[] + def add(dst,src,v,tag): + if v:events.append({'op':'add','dst':dst,'src':src,'q':str(v),'tag':tag}) + def climb(reg,frame,tag): + events.append({'op':'climb','register':reg,'frame':list(frame),'tag':tag}) + for i in range(n): + for c in range(8):add(f'y{i}',f'c{c}',-E[i][c]/8192,'dirt_prefix') + for i in range(n): + if any(E[i]):climb(f'x{i}',U,'source_U') + for c in range(8): + climb(f'c{c}',U,'centre_U') + for i in range(n):add(f'c{c}',f'x{i}',E[i][c],'gather') + for i in range(n):climb(f'x{i}',m.FULL,'source_FULL') + for i in range(n): + if any(E[i]):climb(f'y{i}',W,'target_W') + for c in range(8): + events.append({'op':'private','center':f'c{c}','from':list(U),'to':list(W), + 'targets':[(f'y{i}',str(E[i][c]/8192)) for i in range(n) if E[i][c]], + 'tag':'private_scatter'}) + for c in range(8): + climb(f'c{c}',m.FULL,'centre_FULL') + for i in range(n):add(f'c{c}',f'x{i}',-E[i][c],'cleanup') + for i in range(n):climb(f'y{i}',m.perp(labels[i]),'target_cap') + return {'N':n,'ports':chosen,'E':E,'K':K,'starts':starts,'ends':ends,'events':events} + + +def replay(fix,dual=False,omit=None): + cols=list(fix['starts']);width=len(cols) + rows={r:[F(int(i==j)) for j in range(width)] for i,r in enumerate(cols)} + frames=dict(fix['starts']);paths={r:[] for r in cols} + private_rank=0;primitive=0;peak=F(1);depth=0 + def add(dst,src,v): + nonlocal primitive,peak,depth + need(frames[dst]==frames[src],'literal equal common frame') + rows[dst]=[x+v*y for x,y in zip(rows[dst],rows[src])] + peak=max(peak,sum(map(abs,rows[dst]))) + depth=max(depth,max(x.denominator.bit_length()-1 for x in rows[dst])) + a=abs(v.numerator) + primitive+=3+a.bit_length()-1+a.bit_count()+v.denominator.bit_length()-1 + for event in fix['events']: + if event['tag']==omit:continue + if event['op']=='climb': + r=event['register'];frame=tuple(event['frame']) + need(frame==m.basis(frame) and m.included(frames[r],frame),'ordinary monotone frame') + if len(frame)>len(frames[r]):paths[r].append(len(frame)-len(frames[r])) + frames[r]=frame + elif event['op']=='add': + dst,src,v=event['dst'],event['src'],F(event['q']) + if dual:dst,src,v=src,dst,-v + add(dst,src,v) + else: + c=event['center'];U,W=tuple(event['from']),tuple(event['to']) + targets=[(y,F(v)) for y,v in event['targets']] + need(frames[c]==U and all(frames[y]==W for y,v in targets),'private actual entrance frames') + need(m.included(W,U),'private nested partial frame') + private_rank+=len(U)-len(W) + rows['p']=[F(0)]*width;frames['p']=W if dual else U;primitive+=1 + if dual: + for y,v in targets:add('p',y,v) + frames['p']=U;add(c,'p',-F(1)) + else: + rows['p']=list(rows[c]);primitive+=1 + peak=max(peak,sum(map(abs,rows['p']))) + frames['p']=W + for y,v in targets:add(y,'p',v) + primitive+=1;del rows['p'];del frames['p'] + need(frames==fix['ends'],'every source,target,centre endpoint frame') + for i,r in enumerate(cols): + expected=[F(int(i==j)) for j in range(width)] + if r.startswith('x') and dual: + s=int(r[1:]) + for target in range(fix['N']):expected[cols.index(f'y{target}')]-=fix['K'][target][s] + if r.startswith('y') and not dual: + target=int(r[1:]) + for source in range(fix['N']):expected[cols.index(f'x{source}')]+=fix['K'][target][source] + need(rows[r]==expected,'all arbitrary input and dirty centre columns') + return {'orientation':'dual' if dual else 'forward','paths':paths,'private_rank':private_rank, + 'primitive_before_real_doubling':primitive,'logical_prefix_row_l1':str(peak), + 'logical_prefix_denominator_depth':depth,'ordinary_columns':width} + + +def differential(k,radical,shared=False): + # Unchanged ordinary role count means unchanged stock/pads. Every + # difference is in native paths or in the separate private episodes. + delta=Counter() + if not shared: + for count in (5760,)*(2 if radical else 1): + delta[14]+=count;delta[2]+=count;delta[16]-=count + delta[15]+=8;delta[2]+=8;delta[17]-=8 # ordinary centre paths + private=13 if radical else 15 + delta[private]+=8;delta[17]-=8 + saving=8*(17-private) + need(sum(r*n for r,n in delta.items())==-saving,'complete differential rank mass') + exponent=k+F(1,10**24) + pos=[(F(r*n),r) for r,n in delta.items() if n>0] + neg=[(F(-r*n),r) for r,n in delta.items() if n<0] + pl,pu=b.oracle.pressure(pos,49,exponent) + nl,nu=b.oracle.pressure(neg,49,exponent) + lo,hi=pl-nu-saving,pu-nl-saving + need((hi<0) if shared else (lo>0),'exact gain/loss sign with all stated transport') + # Delta(pressure-D)/L =m^b sum_r DeltaH_r*r^(1-b). + # Its sign is independent of m. The exact m49 interval proves all L. + return {'target':str(k),'exponent_b':str(exponent),'shared_source_target_transport':shared, + 'private_rank_saving':saving,'per_L_rank_count_delta':{r:n for r,n in sorted(delta.items()) if n}, + 'L3_m49_margin_loss_divided_by_L':b.interval(lo,hi), + 'sign_for_every_arity':'IMPROVES_IF_VISITS_ALREADY_PAID' if shared else 'WORSE_WITH_ITS_OWN_DATA_VISITS'} + + +def main(): + roots,packed,q,support,U,radical,chosen=setup() + cases=[];controls=[] + for name,W in (('ZERO',()),('radical2',radical)): + fix=fixture(roots,packed,q,U,W,chosen) + forward,dual=replay(fix),replay(fix,True) + for tag in ('dirt_prefix','gather','private_scatter','cleanup','source_U','centre_U'): + for inv in (False,True): + try:replay(fix,inv,tag) + except ValueError as err:controls.append({'variant':name,'omit':tag,'dual':inv,'gate':str(err)}) + else:raise ValueError('partial centre defect accepted '+tag) + if W: + for inv in (False,True): + try:replay(fix,inv,'target_W') + except ValueError as err:controls.append({'variant':name,'omit':'target_W','dual':inv,'gate':str(err)}) + else:raise ValueError('radical target visit omitted') + cases.append({'name':name,'forward':forward,'dual':dual, + 'full_K_private_C':13872-8*(17-(15-len(W))), + 'full_source_path':[14,2], + 'full_supported_target_path':[len(W),16-len(W)] if W else [16], + 'full_ordinary_selected_centre_path':[15,2], + 'full_selected_private_path':[15-len(W)], + 'differentials':[differential(k,bool(W),sharing) + for k in map(F,('.002','.003','.005')) for sharing in (False,True)]}) + # Full support prefix and lowering receipts follow from the separable + # exact feature values. The full5760 supported ports are not densely replayed. + dual_prefix=max(F(1)+8*sum(abs(x) for x in a[:k]) + +F(3,8)*sum(abs(sum(a[i]*z[i] for i in range(k))) for z in roots) + for a in roots for k in range(9)) + need(dual_prefix==152,'full support exact dual prefix') + primitives=8*(2*(3072*7+672*8)+2*(3072*14+672*13)+3) + need(primitives==1258008,'eight-centre full forward primitive bill') + out={'status':'PASS_ACTUAL_PARTIAL_PAULI_CENTRE_WORDS_AND_COMPLETE_PATH_DIFFERENTIAL_NO_NEW_KAPPA', + 'source_pin':b.PIN,'source_factor':'research/niemeier-lattices/code/e8_sections.py::evaluate_operator_centers', + 'source_columns':[120+44*i for i in range(8)],'weight':1,'denominator':8192, + 'definition':'E_i(a,b)=a_i*sum_j(-1)^(j&1)*b_j^2 in doubled coordinates; zero on both pure blocks.', + 'support_b_lines':[j for j in range(120) if q[j]],'support_ports':5760, + 'feature_nonzeros_each':3744,'feature_abs8_each':3072,'feature_abs16_each':672, + 'source_support_U':list(U),'radical_U_perp':list(radical), + 'ordinary_centres':8,'new_ordinary_centres':0,'cases':cases, + 'full_component_primitives_forward':primitives,'full_component_primitives_dual':primitives+24, + 'full_scalar_primitive_difference_vs_full_width':0, + 'full_subword_logical_prefix_row_l1_forward':35329, + 'full_subword_logical_prefix_row_l1_dual':str(dual_prefix), + 'full_subword_logical_denominator_depth':10, + 'fixture_actual_ports':chosen,'controls':controls, + 'scope':'Two actual eight-centre partial-frame gather/scatter/restore substitutions, full support geometry and exact all-arity moment differential. Whole K identity is inherited unchanged outside these8 columns. Sources visit U once; radical variant supported targets visit Uperp once. They worsen .002/.003/.005 if these data visits are newly paid, and improve if the same visits are already part of another legal network. No transport sharing, full mixed compensation, physical phases, coefficient temporary lowering, approximate-child precision or kappa is claimed.'} + (HERE/'PARTIAL-PAULI-RESULT.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']+' source_ports=5760 U15 radical2 fixtureN='+str(len(chosen))+' controls='+str(len(controls))) + for case in cases: + print(case['name'],'full K C',case['full_K_private_C']) + for row in case['differentials']: + if not row['shared_source_target_transport']: + print(row['target'],'perL margin loss',row['L3_m49_margin_loss_divided_by_L']['lo']) + + +if __name__=='__main__':main() diff --git a/research/h6-partial-frame-networks/pauli/frozen/pauli_partial_review.py b/research/h6-partial-frame-networks/pauli/frozen/pauli_partial_review.py new file mode 100644 index 0000000000..9246c6d17e --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/frozen/pauli_partial_review.py @@ -0,0 +1,351 @@ +#!/usr/bin/env python3 +"""Independent partial-Pauli geometry, dirty word and complete-cost review. + +No complex-alternative producer is imported. Binary frame identities are +checked in intrinsic unimodular E8 pairing coordinates; the fixed canonical +17-bit fit is an isometry of this bilinear space. No physical adapters are +executed or declared free. Apache-2.0; substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from itertools import combinations,product +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +REPO = Path('/Users/ross/git/math/integer-mult-bounds') +SCALE = 10**35 + + +def need(ok,message): + if not ok: + raise ValueError(message) + + +def xor_all(values): + out = 0 + for value in values: + out ^= value + return out + + +def bits(value): + while value: + low = value & -value + yield low.bit_length()-1 + value ^= low + + +def basis(rows): + out = {} + for row in rows: + for j in sorted(out,reverse=True): + if row >> j & 1: + row ^= out[j] + if row: + j = row.bit_length()-1 + for k in list(out): + if out[k] >> j & 1: + out[k] ^= row + out[j] = row + return tuple(out[j] for j in sorted(out,reverse=True)) + + +def included(a,b): + return len(basis(a+b)) == len(b) + + +def inverse(rows): + n = len(rows) + rows = [row | (1 << (n+j)) for j,row in enumerate(rows)] + for j in range(n): + p = next(p for p in range(j,n) if rows[p] >> j & 1) + rows[p],rows[j] = rows[j],rows[p] + for p in range(n): + if p != j and rows[p] >> j & 1: + rows[p] ^= rows[j] + return [row >> n for row in rows] + + +def nullspace(rows,n=17): + rows = list(rows) + pivots,k = [],0 + for j in range(n): + p = next((p for p in range(k,len(rows)) if rows[p] >> j & 1),None) + if p is None: + continue + rows[k],rows[p] = rows[p],rows[k] + for p in range(len(rows)): + if p != k and rows[p] >> j & 1: + rows[p] ^= rows[k] + pivots.append(j) + k += 1 + return basis((1 << f) | sum(((rows[i] >> f)&1) << p for i,p in enumerate(pivots)) + for f in range(n) if f not in pivots) + + +def roots(): + all_roots = [] + for i,j in combinations(range(8),2): + for a,b in product((-2,2),repeat=2): + row = [0]*8 + row[i],row[j] = a,b + all_roots.append(tuple(row)) + all_roots += [r for r in product((-1,1),repeat=8) if sum(r)%4 == 0] + return sorted({r if next(x for x in r if x) > 0 else tuple(-x for x in r) for r in all_roots}) + + +def dot(a,b): + raw = sum(x*y for x,y in zip(a,b)) + need(raw%4 == 0,'actual integral E8 root pairing') + return raw//4 + + +def geometry(): + rr = roots() + gram = [sum((dot(a,b)&1) << j for j,b in enumerate(rr)) for a in rr] + chosen,span = [],() + for i,row in enumerate(gram): + grown = basis(span+(row,)) + if len(grown) > len(span): + chosen.append(i) + span = grown + need(len(chosen) == 8,'E8 pairing rank8') + small = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(chosen)) for i in chosen] + b = inverse(small) + coords = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(chosen)) for i in range(120)] + def pairing8(x,y): + return (xor_all(b[j] for j in bits(x)) & y).bit_count()&1 + need(all(pairing8(coords[i],coords[j]) == (gram[i] >> j)&1 for i in range(120) for j in range(120)), + 'all14400 intrinsic/actual root pairing bindings') + form = tuple(b+[row << 8 for row in b]+[1 << 16]) + def pairing(x,y): + return (xor_all(form[j] for j in bits(x)) & y).bit_count()&1 + def orthogonal(frame): + return nullspace([xor_all(form[j] for j in bits(row)) for row in frame]) + q = [sum((-1 if j&1 else 1)*x*x for j,x in enumerate(r)) for r in rr] + selected = [j for j,value in enumerate(q) if value] + need(len(selected) == 24 and {q[j] for j in selected} == {-8,8},'Pauli24-line support') + ports = [] + for i in range(120): + for j in selected: + for sign in (-1,1): + p = coords[i] | (coords[j] << 8) | (1 << 16) + ports.append((i,j,sign,p,tuple(x*q[j] for x in rr[i]))) + need(len(ports) == 5760,'physical signed support size') + u = basis(p[3] for p in ports) + w = orthogonal(u) + need(len(u) == 15 and len(w) == 2 and included(w,u),'coisotropic U15 with radical2') + need(all(included((p[3],),u) and pairing(p[3],p[3]) == 1 + and all(not pairing(p[3],r) for r in w) for p in ports),'all supported source lines and target caps') + for c in range(8): + need(Counter(abs(p[4][c]) for p in ports if p[4][c]) == {8:3072,16:672},'complete feature incidence census') + # An independent actual fixture contains a rank15 frame witness plus + # coordinate-root witnesses and two actual zero-feature ports. + fixture,span = [],() + for p in ports: + grown = basis(span+(p[3],)) + if len(grown) > len(span): + fixture.append(p) + span = grown + if len(span) == 15: + break + for c in range(8): + fixture.append(next(p for p in ports if abs(p[4][c]) == 16)) + zero_b = next(j for j,value in enumerate(q) if not value) + for i in (0,1): + fixture.append((i,zero_b,1,coords[i] | (coords[zero_b] << 8) | (1 << 16),(0,)*8)) + fixture = list(dict.fromkeys(fixture)) + return rr,form,u,w,ports,fixture,orthogonal + + +def fixture_replay(fixture,u,w,orthogonal,dual=False,omit=None): + n = len(fixture) + labels = [p[3] for p in fixture] + e = [p[4] for p in fixture] + names = [f'x{i}' for i in range(n)]+[f'y{i}' for i in range(n)]+[f'c{i}' for i in range(8)] + rows = {name:[Q(int(i == j)) for j in range(len(names))] for i,name in enumerate(names)} + frames = {name:(basis((labels[i],)) if name.startswith('x') else ()) + for i,name in enumerate(names)} + full = basis(1 << i for i in range(17)) + paths = Counter() + def climb(name,frame,tag): + if tag == omit: + return + need(included(frames[name],frame),'independent monotone frame inclusion') + rank = len(frame)-len(frames[name]) + if rank: + paths[rank] += 1 + frames[name] = frame + def add(name,source,c,tag,dualize=True): + if not c or tag == omit: + return + if dual and dualize: + name,source,c = source,name,-c + need(frames[name] == frames[source],'independent actual common frame') + rows[name] = [a+c*b for a,b in zip(rows[name],rows[source])] + for i in range(n): + for c in range(8): + add(f'y{i}',f'c{c}',-Q(e[i][c],8192),'prefix') + for i in range(n): + if any(e[i]): + climb(f'x{i}',u,'source_U') + for c in range(8): + climb(f'c{c}',u,'centre_U') + for i in range(n): + add(f'c{c}',f'x{i}',Q(e[i][c]),'gather') + for i in range(n): + climb(f'x{i}',full,'source_FULL') + if any(e[i]): + climb(f'y{i}',w,'target_W') + private_rank = 0 + for c in range(8): + if omit == 'private': + continue + need(frames[f'c{c}'] == u and included(w,u),'private nested partial frame') + rows['private'] = [Q(0)]*len(names) + frames['private'] = w if dual else u + private_rank += len(u)-len(w) + if dual: + for i in range(n): + add('private',f'y{i}',Q(e[i][c],8192),'readout',False) + immutable_readout = rows['private'][:] + frames['private'] = u + add(f'c{c}','private',Q(-1),'dual_scatter',False) + need(rows['private'] == immutable_readout,'dual immutable readout lifetime') + else: + rows['private'] = rows[f'c{c}'][:] + frames['private'] = w + for i in range(n): + add(f'y{i}','private',Q(e[i][c],8192),'scatter',False) + need(rows['private'] == rows[f'c{c}'],'original centre snapshot ERASE') + del rows['private'],frames['private'] + for c in range(8): + climb(f'c{c}',full,'centre_FULL') + for i in range(n): + add(f'c{c}',f'x{i}',-Q(e[i][c]),'cleanup') + for i in range(n): + climb(f'y{i}',orthogonal((labels[i],)),'target_cap') + for i,name in enumerate(names): + expected = [Q(int(i == j)) for j in range(len(names))] + if (name.startswith('y') and not dual) or (name.startswith('x') and dual): + target = int(name[1:]) + for j in range(n): + coefficient = Q(sum(a*b for a,b in zip(e[target],e[j])),8192) + expected[n+j if dual else j] += -coefficient if dual else coefficient + need(rows[name] == expected,'all independent source/target/dirty centre columns') + return {'ordinary_input_columns':len(names),'fixture_ports':n,'private_rank':private_rank, + 'ordinary_path_histogram':dict(sorted(paths.items())),'all_input_shear':True} + + +@lru_cache(None) +def rational_power(r,exponent): + numerator,degree = exponent.numerator,exponent.denominator + target = r**numerator*SCALE**degree + # A floating seed is only a speed hint. Exact powers certify the upper + # starting point and exact neighboring powers certify the final interval. + x = int(r**float(exponent)*SCALE)+SCALE//10**12 + while x**degree < target: + x *= 2 + while True: + y = ((degree-1)*x+target//x**(degree-1))//degree + if y >= x: + break + x = y + while x**degree > target: + x -= 1 + while (x+1)**degree <= target: + x += 1 + need(x**degree <= target < (x+1)**degree,'exact rational-power enclosure') + return Q(x,SCALE),Q(x+1,SCALE) + + +def cost(radical,beta,shared=False): + delta = Counter({15:8,2:8,17:-16}) + delta[13 if radical else 15] += 8 + if not shared: + for count in (5760,)*(2 if radical else 1): + delta.update({14:count,2:count,16:-count}) + need(sum(r*n for r,n in delta.items()) == (-32 if radical else -16),'complete rank-mass differential') + lo = hi = Q(0) + for r,n in delta.items(): + a,b = rational_power(r,1-beta) + lo += n*(a if n >= 0 else b) + hi += n*(b if n >= 0 else a) + # Exponent beta+10^-24 changes the normalized delta by less than this + # bound, because |d r^(1-beta)/d beta|<=r log r<3r for r<=17,beta>=0. + perturbation = Q(3*sum(abs(n)*r for r,n in delta.items()),10**24) + need(hi+perturbation < 0 if shared else lo-perturbation > 0,'complete moment sign') + ml,mh = rational_power(49,beta) + actual_lo = lo*(ml if lo >= 0 else mh) + actual_hi = hi*(mh if hi >= 0 else ml) + return {'radical':radical,'beta':str(beta),'shared_data_visits':shared, + 'profile_delta':dict(sorted(delta.items())), + 'normalized_delta_interval':list(map(str,(lo,hi))), + 'm49_delta_interval':list(map(str,(actual_lo,actual_hi))), + 'tiny_exponent_perturbation_bound':str(perturbation), + 'sign':'improves conditionally' if shared else 'worsens with new data visits'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write',action='store_true') + args = parser.parse_args() + rr,form,u,w,ports,fixture,orthogonal = geometry() + cases,controls = [],[] + for radical,frame in ((False,()),(True,w)): + forward = fixture_replay(fixture,u,frame,orthogonal) + dual = fixture_replay(fixture,u,frame,orthogonal,True) + for omit in ('prefix','gather','cleanup','source_U','private'): + try: + fixture_replay(fixture,u,frame,orthogonal,omit=omit) + except ValueError as error: + controls.append(str(error)) + else: + raise ValueError('independent omission control accepted') + if radical: + try: + fixture_replay(fixture,u,frame,orthogonal,omit='target_W') + except ValueError as error: + controls.append(str(error)) + else: + raise ValueError('unpaid radical target visit accepted') + cases.append({'radical':radical,'forward':forward,'dual':dual, + 'full_K_private_bill':13840 if radical else 13856, + 'costs':[cost(radical,beta,shared) for beta in map(Q,('.002','.003','.005')) for shared in (False,True)]}) + primary = [REPO/'research/niemeier-lattices/code/e8_cubed.py', + REPO/'research/niemeier-lattices/code/e8_sections.py'] + primitive = 8*(2*(3072*7+672*8)+2*(3072*14+672*13)+3) + need(primitive == 1258008,'selected component primitive bill') + result = {'status':'PASS_INDEPENDENT_PARTIAL_PAULI_GEOMETRY_DIRTY_WORD_AND_COMPLETE_COST', + 'primary_sources':{str(p.relative_to(REPO)):sha256(p.read_bytes()).hexdigest() for p in primary}, + 'reviewed_producer_sha256':sha256((HERE.parent/'complex-alternative/partial_pauli.py').read_bytes()).hexdigest(), + 'physical_supported_ports':len(ports),'feature_incidence_each':3744, + 'feature_columns':[120+44*i for i in range(8)],'coefficient_denominator':8192, + 'intrinsic_bilinear_form':form,'intrinsic_U':u,'intrinsic_U_perp':w, + 'all_support_source_and_target_inclusions':True, + 'full_component_forward_primitive_bound':primitive,'full_component_dual_primitive_bound':primitive+24, + 'all_input_written_law':'c=d+E^T x; y=y0-E d/8192+E(d+E^T x)/8192=y0+E E^T x/8192; c restored by-E^T x. Dual phases give x-=E E^T y/8192 with d restored.', + 'fixture_ports':[[i,j,s] for i,j,s,p,e in fixture], 'cases':cases,'controls':controls, + 'frame_binding':'Intrinsic pairing coordinates use the actual E8 Gram inverse. The canonical17-bit fit is an isometry of this nondegenerate bilinear space; dimensions, inclusions and orthogonal complements therefore transfer to its fixed actual labels. No new free physical permutation is asserted.', + 'all_arity_sign_proof':'Delta moment=m^beta sum_r delta_H[r] r^(1-beta). The parent factor m^beta is positive for every arity; the exact enclosed signs are independent of m.', + 'limits':['full5760 support geometry and an all-parameter written arbitrary-input factor identity; bounded actual-port fixture is not dense fullK replay', + 'private snapshot/readout erasure uses the inherited exact centre-copy and same-order dual interface', + 'physical Clifford phases/adapters, coefficient temporary lowering, approximate children, precision and tape remain separate', + 'conditional sharing requires already-paid identical U and Uperp visits in a compatible chronology; none is supplied here', + 'no completed H6 supplier or kappa gain']} + path = HERE/'PARTIAL-PAULI-REVIEW.json' + if args.write: + path.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == json.loads(json.dumps(result)),'complete independent partial Pauli receipt differs') + print(result['status']) + print('U15, radical2, supported5760; standalone worsens .002/.003/.005 at every arity') + + +if __name__ == '__main__': + main() diff --git a/research/h6-partial-frame-networks/pauli/geometry.py b/research/h6-partial-frame-networks/pauli/geometry.py new file mode 100644 index 0000000000..a7f279b788 --- /dev/null +++ b/research/h6-partial-frame-networks/pauli/geometry.py @@ -0,0 +1,126 @@ +"""Source-faithful standard-library geometry adaptation for the C03 Pauli audit. + +Frozen source hashes and the literal adaptations are recorded in ORIGINS.json. +No historical module imports, ambient repository reads, NumPy or Git calls. +Substantial OpenAI Codex assistance; inherited source attribution is preserved. +""" +from itertools import combinations, product +H=17 +FULL=tuple(1 << i for i in reversed(range(H))) + +def need(ok, label): + if not ok: raise ValueError(label) + +def basis(words): + piv = {} + for v in words: + for k in sorted(piv, reverse=True): + if v >> k & 1: v ^= piv[k] + if v: + k = v.bit_length()-1 + for j in list(piv): + if piv[j] >> k & 1: piv[j] ^= v + piv[k] = v + return tuple(piv[k] for k in sorted(piv, reverse=True)) + +def included(a,b): return len(basis(a+b)) == len(b) + +def perp(v): + k = (v & -v).bit_length()-1 + return basis((1 << i) ^ ((1 << k) if v >> i & 1 else 0) for i in range(H) if i != k) + +def mm(a,b): + return [xor(b[j] for j in range(len(b)) if row >> j & 1) for row in a] + +def xor(xs): + z = 0 + for x in xs: z ^= x + return z + +def tr(a,n): return [sum(((row >> j) & 1) << i for i,row in enumerate(a)) for j in range(n)] + +def inv(a): + n = len(a); work = [row | (1 << (n+i)) for i,row in enumerate(a)] + for j in range(n): + p = next(i for i in range(j,n) if work[i] >> j & 1) + work[j],work[p] = work[p],work[j] + for i in range(n): + if i != j and work[i] >> j & 1: work[i] ^= work[j] + need([r & ((1<> n for r in work] + +def cong(t,m): return mm(mm(t,m),tr(t,len(t))) + +def symp(m): + n = len(m); t = [1<> b & 1) + for cur,dst in ((a,k),(b if b != k else a,k+1)): + t[cur],t[dst] = t[dst],t[cur] + work = cong(t,m) + for i in range(k+2,n): + left,right = (work[i] >> (k+1)) & 1,(work[i] >> k) & 1 + if left: t[i] ^= t[k] + if right: t[i] ^= t[k+1] + work = cong(t,m) + need(work == [1 << (i^1) for i in range(n)], "symplectic congruence") + return t + +def canonical_roots(): + roots = [] + for i,j in combinations(range(8),2): + for x,y in product((-2,2),repeat=2): + a = [0]*8; a[i],a[j] = x,y; roots.append(tuple(a)) + roots.extend(a for a in product((-1,1),repeat=8) if sum(a) % 4 == 0) + return sorted({a if next(x for x in a if x) > 0 else tuple(-x for x in a) for a in roots}) + +def dot(a,b): + z = sum(x*y for x,y in zip(a,b)) + need(z % 4 == 0, "integral E8 pairing") + return z//4 + +def packed_root_pairs(roots): + # Same exact lattice-to17-bit fit as mixed_rectangle.actual_labels, + # but without its quadratic all-pairs diagnostic on the whole domain. + gram = [sum((dot(a,c)&1) << j for j,c in enumerate(roots)) for a in roots] + work = list(gram) + available, selected = list(range(120)), [] + while any(work[a] >> c & 1 for a in available for c in available): + a,c = next((a,c) for a in available for c in available if work[a] >> c & 1) + selected.extend((a,c)) + left, right = work[a], work[c] + work = [row ^ (right if left >> i & 1 else 0) + ^ (left if right >> i & 1 else 0) + for i,row in enumerate(work)] + available.remove(a) + available.remove(c) + small = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in selected] + inverse = inv(small) + form = inverse+[row << 8 for row in inverse] + even = [((1 << 16)-1) ^ (1 << i) for i in range(16)] + change = mm(inv(symp(form)), symp(even)) + need(cong(change, even) == form, 'pinned standard-dot isometry') + mapping = mm(change, [(1 << i)|(1 << 16) for i in range(16)]) + coordinates = [sum(((gram[i] >> j)&1) << k for k,j in enumerate(selected)) + for i in range(120)] + return [[((1 << 17)-1) ^ mm([x|(y << 8)], mapping)[0] + for y in coordinates] for x in coordinates] + +def orthogonal_involution(roots): + position = {a:i for i,a in enumerate(roots)} + mates = [] + for a in roots: + c = list(a) + if all(x % 2 == 0 for x in a): + nonzero = [i for i,x in enumerate(a) if x] + c[nonzero[1]] *= -1 + else: + for i in range(4,8): + c[i] *= -1 + mates.append(position[tuple(c)]) + need(all(i != j and mates[j] == i and dot(roots[i], roots[j]) == 0 + for i,j in enumerate(mates)), 'explicit120-root orthogonal involution') + pairs = [(i,j) for i,j in enumerate(mates) if i < j] + need(len(pairs) == 60, 'sixty orthogonal b-pairs') + return pairs diff --git a/research/h6-partial-frame-networks/reviews/CONTROL-VALIDATION.json b/research/h6-partial-frame-networks/reviews/CONTROL-VALIDATION.json new file mode 100644 index 0000000000..c0af69c426 --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/CONTROL-VALIDATION.json @@ -0,0 +1,21 @@ +{ + "child_modes": [ + 0, + 1 + ], + "commands": [ + "python3 -I -B controls.py --package PACKAGE --output EXTERNAL_NEW_CONTROLS.json", + "python3 -I -B -O controls.py --package PACKAGE --output EXTERNAL_NEW_CONTROLS-O.json" + ], + "control_source_sha256": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de", + "controls_sha256": "89c6364cfb3fa73ce1fb3f2c693c8e90a8ff171097e28bf383e88eeb6de2c2ac", + "executed_named_check_deletions_per_mode": 16, + "full_science_stages_replayed": false, + "full_scientific_records": 3, + "intended_rejections_per_mode": 67, + "normal_and_optimized_outer_receipts_byte_identical": true, + "package": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c03-staging", + "python_executable": "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "python_version": "3.12.14", + "status": "PASS" +} diff --git a/research/h6-partial-frame-networks/reviews/CONTROLS.json b/research/h6-partial-frame-networks/reviews/CONTROLS.json new file mode 100644 index 0000000000..d18945f45f --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/CONTROLS.json @@ -0,0 +1,803 @@ +{ + "control_source_sha256": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de", + "executed_check_deletions_per_mode": 16, + "full_scientific_receipts_compared": 3, + "full_scientific_stages_replayed": false, + "intended_rejections_per_mode": 67, + "no_new_kappa": true, + "normal_and_optimized_receipts_equal_except_mode": true, + "runs": [ + { + "compression": { + "equivalent_recompression_accepted": true, + "rejections": [ + { + "intended_gate": "changed frozen input: original.json.gz", + "name": "changed_compressed_input" + }, + { + "intended_gate": "origin digest mismatch: original.json.gz", + "name": "changed_container_origin" + }, + { + "intended_gate": "original decoded bytes changed: original.json.gz", + "name": "changed_original_after_transport_rebinding" + }, + { + "intended_gate": "frozen/origin inventory mismatch", + "name": "omitted_origin" + } + ] + }, + "contracts": { + "authenticated_original_contract": { + "frame_cases": 2400, + "frame_cases_sha256": "90b0a4049066b6eb08ab223ba03d8f9af95bbe688a09c4ee5c7f586ad1fdd46b" + }, + "executed_check_deletions": 9, + "mutations_after_authentication": true, + "rejections": [ + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_array_changed" + }, + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_scalar_type_changed" + }, + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_order_changed" + }, + { + "intended_gate": "complete tiling frame count", + "name": "frame_count_both_truncated" + }, + { + "intended_gate": "complete tiling frame digest mismatch", + "name": "declared_digest_changed" + }, + { + "intended_gate": "complete shared geometry differs: canonical_roots", + "name": "shared_canonical_roots" + }, + { + "intended_gate": "complete shared geometry differs: a_triples", + "name": "shared_a_triples" + }, + { + "intended_gate": "complete shared geometry differs: b_orthogonal_involution_pairs", + "name": "shared_b_orthogonal_involution_pairs" + }, + { + "intended_gate": "complete shared geometry differs: triple_gauge_signs", + "name": "shared_triple_gauge_signs" + } + ] + }, + "coverage": { + "executed_check_deletions": 1, + "real_dispatch_covered_with_tiny_receipts": true, + "rejections": [ + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_extra" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_extra" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_extra" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "omitted_actual_compare" + } + ], + "stage_counts": { + "cyclic": 1, + "independent": 1, + "pauli": 1 + } + }, + "loader": { + "captured_source_survives_disposable_path_change": true, + "child_assertions_enabled": true, + "file_and_argument_semantics_preserved": true, + "rejections": [ + { + "intended_gate": "AssertionError: DIRECT_ASSERT", + "name": "direct.py" + }, + { + "intended_gate": "AssertionError: NESTED_ASSERT", + "name": "nested.py" + }, + { + "intended_gate": "changed frozen input: direct.py", + "name": "changed_executable_source" + }, + { + "intended_gate": "missing regular input: direct.py", + "name": "missing_executable_source" + }, + { + "intended_gate": "unregistered input: absent.py", + "name": "unregistered_source" + }, + { + "intended_gate": "unsafe package path", + "name": "absolute_path" + }, + { + "intended_gate": "unsafe package path", + "name": "parent_escape" + }, + { + "intended_gate": "missing regular input: link.py", + "name": "symlink_input" + }, + { + "intended_gate": "input escapes package", + "name": "ancestor_symlink_escape" + }, + { + "intended_gate": "DIRECT_RUNTIME_GATE", + "name": "direct_runtime_requirement" + } + ] + }, + "nested_sources": { + "actual_captured_loader_survives_disposable_source_change": true, + "full_science_stages_replayed": false, + "no_path_import_or_pyc_execution_used": true, + "rejections": [ + { + "intended_gate": "GEOMETRY_NESTED_ASSERT", + "name": "nested_geometry_assertion" + }, + { + "intended_gate": "source manifest SHA256", + "name": "changed_nested_manifest" + }, + { + "intended_gate": "authenticated source bytes: invoice.py", + "name": "changed_retained_executable" + }, + { + "intended_gate": "RETAINED_NESTED_ASSERT", + "name": "retained_nested_assertion_with_disposable_pin" + }, + { + "intended_gate": "unique source adaptation", + "name": "duplicate_literal_adapter_match" + }, + { + "intended_gate": "authenticated source bytes", + "name": "changed_selected_literal_source" + }, + { + "intended_gate": "unique frozen TRIPLES assignment", + "name": "duplicate_selected_TRIPLES" + }, + { + "intended_gate": "unique frozen TRIPLES assignment", + "name": "missing_selected_TRIPLES" + } + ], + "retained_compile_optimization": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "retained_module_count": 6 + }, + "output": { + "guards_precede_scientific_replay": true, + "rejections": [ + { + "intended_gate": "output must be absolute", + "name": "relative_wrapper_output" + }, + { + "intended_gate": "output already exists", + "name": "existing_wrapper_output" + }, + { + "intended_gate": "output must be external", + "name": "internal_wrapper_output" + } + ] + }, + "parent_optimization": 0, + "real_records": [ + { + "nested_path": [ + "reports", + "CYCLIC-MIXED-RESULT.json", + "cases", + 0, + "fixture", + "events", + 48, + "targets", + 0, + 0 + ], + "record": "cyclic/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: cyclic/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: cyclic/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4" + }, + { + "nested_path": [ + "pauli", + "cases", + 0, + "orientations", + 0, + "invoice", + "paths", + "c0", + 0 + ], + "record": "independent/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc" + }, + { + "nested_path": [ + "cases", + 0, + "fixture", + "events", + 165, + "targets", + 0, + 0 + ], + "record": "pauli/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: pauli/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: pauli/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4" + } + ], + "record_gate": { + "named_record_gate_deletion_detected": true, + "rejections": [ + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "boolean_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "float_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "integer_for_boolean" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "nested_omission" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_reorder" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_truncate" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "duplicate_json_key" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "nested_duplicate_json_key" + }, + { + "intended_gate": "nonfinite JSON constant: NaN", + "name": "nonfinite_NaN" + }, + { + "intended_gate": "nonfinite JSON constant: Infinity", + "name": "nonfinite_Infinity" + }, + { + "intended_gate": "nonfinite JSON constant: -Infinity", + "name": "nonfinite_-Infinity" + }, + { + "intended_gate": "missing regular input: expected.json", + "name": "missing_expected_record" + } + ] + }, + "scientific_gates": { + "executed_check_deletions": 5, + "full_science_stages_replayed": false, + "one_r3_and_one_radical_diagnostic_only": true, + "ordinary_corruption_tests_after_source_authentication": true, + "rejections": [ + { + "intended_gate": "all-column exact identity with arbitrary dirt", + "name": "cyclic_actual_dirty_helper_cleanup" + }, + { + "intended_gate": "equal current frames", + "name": "cyclic_actual_source_frame" + }, + { + "intended_gate": "complete scalar invoice", + "name": "cyclic_actual_paid_cancelling_pair" + }, + { + "intended_gate": "all arbitrary input and dirty centre columns", + "name": "pauli_actual_cleanup" + }, + { + "intended_gate": "literal equal common frame", + "name": "pauli_actual_target_W" + } + ] + } + }, + { + "compression": { + "equivalent_recompression_accepted": true, + "rejections": [ + { + "intended_gate": "changed frozen input: original.json.gz", + "name": "changed_compressed_input" + }, + { + "intended_gate": "origin digest mismatch: original.json.gz", + "name": "changed_container_origin" + }, + { + "intended_gate": "original decoded bytes changed: original.json.gz", + "name": "changed_original_after_transport_rebinding" + }, + { + "intended_gate": "frozen/origin inventory mismatch", + "name": "omitted_origin" + } + ] + }, + "contracts": { + "authenticated_original_contract": { + "frame_cases": 2400, + "frame_cases_sha256": "90b0a4049066b6eb08ab223ba03d8f9af95bbe688a09c4ee5c7f586ad1fdd46b" + }, + "executed_check_deletions": 9, + "mutations_after_authentication": true, + "rejections": [ + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_array_changed" + }, + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_scalar_type_changed" + }, + { + "intended_gate": "complete tiling frame arrays differ", + "name": "frame_order_changed" + }, + { + "intended_gate": "complete tiling frame count", + "name": "frame_count_both_truncated" + }, + { + "intended_gate": "complete tiling frame digest mismatch", + "name": "declared_digest_changed" + }, + { + "intended_gate": "complete shared geometry differs: canonical_roots", + "name": "shared_canonical_roots" + }, + { + "intended_gate": "complete shared geometry differs: a_triples", + "name": "shared_a_triples" + }, + { + "intended_gate": "complete shared geometry differs: b_orthogonal_involution_pairs", + "name": "shared_b_orthogonal_involution_pairs" + }, + { + "intended_gate": "complete shared geometry differs: triple_gauge_signs", + "name": "shared_triple_gauge_signs" + } + ] + }, + "coverage": { + "executed_check_deletions": 1, + "real_dispatch_covered_with_tiny_receipts": true, + "rejections": [ + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: cyclic", + "name": "cyclic_extra" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "pauli_extra" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_extra" + }, + { + "intended_gate": "complete stage record coverage changed: pauli", + "name": "omitted_actual_compare" + } + ], + "stage_counts": { + "cyclic": 1, + "independent": 1, + "pauli": 1 + } + }, + "loader": { + "captured_source_survives_disposable_path_change": true, + "child_assertions_enabled": true, + "file_and_argument_semantics_preserved": true, + "rejections": [ + { + "intended_gate": "AssertionError: DIRECT_ASSERT", + "name": "direct.py" + }, + { + "intended_gate": "AssertionError: NESTED_ASSERT", + "name": "nested.py" + }, + { + "intended_gate": "changed frozen input: direct.py", + "name": "changed_executable_source" + }, + { + "intended_gate": "missing regular input: direct.py", + "name": "missing_executable_source" + }, + { + "intended_gate": "unregistered input: absent.py", + "name": "unregistered_source" + }, + { + "intended_gate": "unsafe package path", + "name": "absolute_path" + }, + { + "intended_gate": "unsafe package path", + "name": "parent_escape" + }, + { + "intended_gate": "missing regular input: link.py", + "name": "symlink_input" + }, + { + "intended_gate": "input escapes package", + "name": "ancestor_symlink_escape" + }, + { + "intended_gate": "DIRECT_RUNTIME_GATE", + "name": "direct_runtime_requirement" + } + ] + }, + "nested_sources": { + "actual_captured_loader_survives_disposable_source_change": true, + "full_science_stages_replayed": false, + "no_path_import_or_pyc_execution_used": true, + "rejections": [ + { + "intended_gate": "GEOMETRY_NESTED_ASSERT", + "name": "nested_geometry_assertion" + }, + { + "intended_gate": "source manifest SHA256", + "name": "changed_nested_manifest" + }, + { + "intended_gate": "authenticated source bytes: invoice.py", + "name": "changed_retained_executable" + }, + { + "intended_gate": "RETAINED_NESTED_ASSERT", + "name": "retained_nested_assertion_with_disposable_pin" + }, + { + "intended_gate": "unique source adaptation", + "name": "duplicate_literal_adapter_match" + }, + { + "intended_gate": "authenticated source bytes", + "name": "changed_selected_literal_source" + }, + { + "intended_gate": "unique frozen TRIPLES assignment", + "name": "duplicate_selected_TRIPLES" + }, + { + "intended_gate": "unique frozen TRIPLES assignment", + "name": "missing_selected_TRIPLES" + } + ], + "retained_compile_optimization": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "retained_module_count": 6 + }, + "output": { + "guards_precede_scientific_replay": true, + "rejections": [ + { + "intended_gate": "output must be absolute", + "name": "relative_wrapper_output" + }, + { + "intended_gate": "output already exists", + "name": "existing_wrapper_output" + }, + { + "intended_gate": "output must be external", + "name": "internal_wrapper_output" + } + ] + }, + "parent_optimization": 1, + "real_records": [ + { + "nested_path": [ + "reports", + "CYCLIC-MIXED-RESULT.json", + "cases", + 0, + "fixture", + "events", + 48, + "targets", + 0, + 0 + ], + "record": "cyclic/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: cyclic/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: cyclic/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4" + }, + { + "nested_path": [ + "pauli", + "cases", + 0, + "orientations", + 0, + "invoice", + "paths", + "c0", + 0 + ], + "record": "independent/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc" + }, + { + "nested_path": [ + "cases", + 0, + "fixture", + "events", + 165, + "targets", + 0, + 0 + ], + "record": "pauli/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: pauli/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: pauli/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4" + } + ], + "record_gate": { + "named_record_gate_deletion_detected": true, + "rejections": [ + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "boolean_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "float_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "integer_for_boolean" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "nested_omission" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_reorder" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_truncate" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "duplicate_json_key" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "nested_duplicate_json_key" + }, + { + "intended_gate": "nonfinite JSON constant: NaN", + "name": "nonfinite_NaN" + }, + { + "intended_gate": "nonfinite JSON constant: Infinity", + "name": "nonfinite_Infinity" + }, + { + "intended_gate": "nonfinite JSON constant: -Infinity", + "name": "nonfinite_-Infinity" + }, + { + "intended_gate": "missing regular input: expected.json", + "name": "missing_expected_record" + } + ] + }, + "scientific_gates": { + "executed_check_deletions": 5, + "full_science_stages_replayed": false, + "one_r3_and_one_radical_diagnostic_only": true, + "ordinary_corruption_tests_after_source_authentication": true, + "rejections": [ + { + "intended_gate": "all-column exact identity with arbitrary dirt", + "name": "cyclic_actual_dirty_helper_cleanup" + }, + { + "intended_gate": "equal current frames", + "name": "cyclic_actual_source_frame" + }, + { + "intended_gate": "complete scalar invoice", + "name": "cyclic_actual_paid_cancelling_pair" + }, + { + "intended_gate": "all arbitrary input and dirty centre columns", + "name": "pauli_actual_cleanup" + }, + { + "intended_gate": "literal equal common frame", + "name": "pauli_actual_target_W" + } + ] + } + } + ], + "source_hashes": { + "FROZEN-SHA256.json": "73c279f7f25a1e707fe1e3cd42e7d945c6c077d61dd252d54b70a5674361494c", + "ORIGINS.json": "9b2de4b3353bc6bba6e336301b93034d6d935f3e769967f2b96932279e0d9126", + "cyclic/check.py": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e", + "independent/independent_operator.py": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382", + "pauli/check.py": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66", + "pauli/geometry.py": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25", + "verify.py": "db07043a36beac98813b35a9380cb2799dd0507348ab4aa62200ce65f9513c1b" + }, + "status": "PASS_C03_COMPACT_SOURCE_RECORD_AND_SEMANTIC_CONTROLS" +} diff --git a/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI-CHECK.json b/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI-CHECK.json new file mode 100644 index 0000000000..91bee2b303 --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI-CHECK.json @@ -0,0 +1,97 @@ +{ + "component_primitives": [ + 1258008, + 1258032 + ], + "cyclic_receipt_raw_sha256": "f06ada7495619759967cc1160a1012d8ed12e527970fd389717c4ef9b78cc832", + "frame_cases": 2400, + "frame_cases_sha256": "90b0a4049066b6eb08ab223ba03d8f9af95bbe688a09c4ee5c7f586ad1fdd46b", + "full_arrays_equal": [ + "frame_cases", + "a_triples", + "b_pairs", + "triple_gauge_signs" + ], + "independently_recounted_cyclic_deltas": { + "ZERO": { + "2": 5768, + "12": 5760, + "14": -5760, + "15": 16, + "17": -16 + }, + "radical2": { + "1": 5760, + "2": 17288, + "3": -5760, + "12": 11520, + "13": 8, + "14": -11520, + "15": 8, + "17": -16 + } + }, + "independently_recounted_histograms": { + "reader": { + "1": 11520, + "2": 5760, + "13": 5760 + }, + "source": { + "1": 11520, + "2": 5760, + "12": 5760 + }, + "target": { + "2": 11520, + "12": 5760 + } + }, + "individual_feature_abs_counts": [ + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + }, + { + "8": 3072, + "16": 672 + } + ], + "method": "Standard-library JSON reading plus independent binary Gaussian elimination and per-role path census. No source imports or full checker rerun. Chronology and arbitrary-dirt factor law reviewed separately in CROSS-REVIEW-PAULI.md.", + "reviewed_pauli_sha256": { + "CHECKS.json": "dd2bd852b6b5b3c78f2e0cb6a5e6aff49cf4f3956aa18673bd555bfb6b069220", + "CHECKS.json.gz": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4", + "OUTPUT-INVENTORY.json": "e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987", + "PROOF.md": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c", + "check.py": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66" + }, + "selected_b_pairs": 12, + "selected_joins": 1440, + "selected_signed_modules": 960, + "status": "PASS_INDEPENDENT_PAULI_CYCLIC_CONTRACT_RECOUNT", + "supported_signed_ports": 5760 +} diff --git a/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI.md b/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI.md new file mode 100644 index 0000000000..48c7e30958 --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/CROSS-REVIEW-PAULI.md @@ -0,0 +1,154 @@ +# Independent review of the partial-Pauli cyclic refinement + +Verdict: PASS for the precise logical frame model and the finite construction +stated in the Pauli proof. No outstanding mathematical finding was identified. +This review was completed against the frozen files below on 2026-10-20 UTC. +It is a new companion review; the frozen cyclic core and its inventory were +not modified. + +## Reviewed bytes and independent evidence + +The reviewed Pauli package is the sibling contribution `c03-pauli`. Its +scientific snapshot is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +| File | SHA-256 | +| --- | --- | +| `check.py` | `97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66` | +| `PROOF.md` | `74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c` | +| `CHECKS.json`, recovered from the transport | `dd2bd852b6b5b3c78f2e0cb6a5e6aff49cf4f3956aa18673bd555bfb6b069220` | +| `CHECKS.json.gz` | `8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4` | +| `OUTPUT-INVENTORY.json` | `e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987` | + +Every entry in that inventory was freshly checked for byte length and digest. +The compressed receipt was freshly decompressed and compared with the raw +receipt. The independent cyclic receipt used for reconciliation has raw +SHA-256 `f06ada7495619759967cc1160a1012d8ed12e527970fd389717c4ef9b78cc832`. + +`CROSS-REVIEW-PAULI-CHECK.json`, SHA-256 +`569ac24b666e6260e5efab3f9a718c28e4e16a702ea1f7dcb22010fedafbfc8c`, +records a fresh independent recount. That recount reads JSON as data, uses a +separate binary Gaussian elimination routine, and imports no checker code. +It compares the complete arrays of 2,400 frame cases, 40 triples, 60 pairs, +and all triple gauge signs. It also reconstructs every selected join, the +separate role histograms, the complete changed histograms, and the eight +individual scalar-support censuses. The shared canonical frame-array digest +is `90b0a4049066b6eb08ab223ba03d8f9af95bbe688a09c4ee5c7f586ad1fdd46b`. + +This is source/proof review plus the stated independent finite recount. It +does not repeat the author's complete normal/optimized run or the other +reviewer's ordinary-column/control audit. + +## Mathematical interface and restoration + +The selected polynomial is `E_i(a,b)=a_i q(b)`, where +`q(b)=sum_j (-1)^j b_j^2`. Inspection of the retained evaluator agrees with +the index translation `120+44i`, weight 1 and denominator 8192. The retained +NumPy evaluator is not claimed to have been executed by the portable audit. +The independently counted support has 5,760 signed physical ports; every +individual feature has 3,072 coefficients of absolute value 8 and 672 of +absolute value 16. This reproduces the component primitive invoices +1,258,008 forward and 1,258,032 dual, including their distinct private bills. + +For arbitrary ordinary dirt `d`, the forward word has target change +`-E d/8192 + E(d+E^T x)/8192 = E E^T x/8192`, followed by centre cleanup. +The same-chronology logical inverse transpose yields source change +`-E(d+E^T y/8192)+E d = -E E^T y/8192`, with centre dirt restored. The proof +correctly gives a separate dual private readout interface: it does not take +an inverse transpose of a destructive CLEAR. Forward source immutability is +used only in the forward substitution and schedule. It is not incorrectly +assumed for the changing source rows of the dual word. + +These statements concern logical values under fixed representatives `T_A`. +Ordinary centres start at ZERO and finish at FULL. Their final logical value +is their initial dirt, while their final physical value is `T_FULL d`. +The proof expressly retains this physical endpoint transport. The support +space U has dimension 15 and radical W of dimension 2; W is contained in U. +The frame and private dimension-difference tariffs are explicit assumptions, +including for these degenerate spaces. No native phase, raw-return, or +physical inverse-transpose theorem is inferred from the binary inclusions. + +## Actual common-frame chronology + +Exactly 12 b-pairs are supported by q, so precisely 960 of the 4,800 signed +cyclic modules are affected. The source and target arc indices agree with +the cyclic word, including its cyclic direction and excluded target group. +All 1,440 selected triple/pair/group records have signed multiplicity four. + +The independent elimination confirms for every selected record that the +source's final rank-three arc lies in U, and that the target delivery arc A +has `dim(A intersect W)=1`. Thus `W` is not contained in A. One cannot insert +a free monotone target visit `ZERO -> W -> A`. The actual join `J=A+W` has +dimension four and lies in each receiving target cap. The revised delivery +is legal because both target and reader are at the identical representative +`T_J` when the original scalar coefficients are applied. + +The following dependencies are satisfied by the written global schedule: + +1. All ZERO dirt prefixes and residual edge-helper loads occur before their + data operands leave the required ZERO/source-line frames. +2. The cyclic gathers finish before the selected sources enter U. Those + sources remain there for the eight selected centre gathers, then move + to FULL. +3. All unchanged 808-centre ZERO outputs finish before affected targets + enter W. Selected output occurs at ZERO or W according to its stated + private variant, with centres then cleaning up at FULL. +4. Radical targets move W to J, and their module readers move their old arc + to the same J before cyclic delivery. Unaffected modules retain their + existing frames. Targets then reach their caps for residual delivery; + ordinary readers finish their logical cleanup at FULL. + +No new ordinary role is required. No selected Pauli coefficient changes the +cyclic sign gauge: the latter remains absorbed in its own gather/delivery +coefficients. The same frame chronology supports the logical dual because +each dualized scalar ADD still has a common representative, and the private +dual interface was separately specified. + +## Complete role invoice and the decision it supports + +The independently reconstructed affected paths are + +| Role | Original increments | Radical refinement | +| --- | --- | --- | +| source | `[1,1,14]` | `[1,1,12,2]` | +| target | `[3,13]` | `[2,2,12]` | +| cyclic reader | `[2,1,14]` | `[2,1,1,13]` | + +There are 5,760 instances of each affected role. For ZERO output only the +source path changes. The eight selected centres change `[17]` to `[15,2]`; +their private events change rank 17 to rank 15 or 13. Separately including +the reader change is essential. With `H_r` denoting a rank-r event, direct +subtraction gives + +``` +ZERO: 5760*(H12+H2-H14) + 8*(2H15+H2-2H17), +radical: 5760*(H1+3H2+2H12-H3-2H14) + + 8*(H15+H2+H13-2H17). +``` + +The rank masses are -16 and -32, entirely from the private saving. The +complete paid power comparison uses every displayed term, rather than +substituting that smaller rank mass for its concave moment. The source's +rational power enclosure, sign propagation, and threshold-neighbor tests +were inspected. Their integer inequalities bind the result independently of +the floating initial root guess. The derivative bound used for the +`10^-24` exponent shift is valid for all recorded ranks at most 17. + +At the three stated exponents, the fully charged standalone and actual +cyclic refinements worsen the stated moment. The positive factor `m^beta` +does not change this sign. The admitted full invoice is restricted to odd +L at least 3, where the cap admits every rank at most 17 without splitting. +No L=1 capped-invoice result is inferred. The threshold table concerns +another hypothetical word with identical visits already paid; it is not a +certificate that the present cyclic word supplies them. + +## Evidence limits + +The proof clearly separates the four 46-column diagnostics, the exhaustive +finite support/frame data, and the all-input factor identity. It does not +claim a dense 5,760-port replay, a rerun of the full 816-centre background, +whole-supplier precision, a native compiler, physical stock/owner access, +or a new multiplication bound. The logical prefix bounds and dyadic depth +are appropriately limited to the selected subword. The rank-34 restriction +is confined to the stated 35-dimensional quadratic evaluation family. + +No additional mathematical correction is requested for this frozen version. diff --git a/research/h6-partial-frame-networks/reviews/REVIEW-VERIFICATION.md b/research/h6-partial-frame-networks/reviews/REVIEW-VERIFICATION.md new file mode 100644 index 0000000000..c75d735aa0 --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/REVIEW-VERIFICATION.md @@ -0,0 +1,158 @@ +# C03 independent operator and source-control review + +Review disposition: PASS for the stated logical frame/private-interface model +and the exact candidate identified below. No remaining mathematical or +source-control blocker was found within that scope. This is a separate AI +review context, not independent human review or formal-kernel acceptance. + +The reviewed candidate is the 61-file inventory in `CORE-SNAPSHOT.json`, whose +file SHA-256 is +`91102ae9e019a6b725c6960dce1993974a19650f7149790da940cce87c4371db`. +Every listed byte length and digest was checked against the actual staging +files. At that check, only the snapshot itself was outside its inventory. +This report is a later review output deliberately outside that inventory; +it does not create a circular self-hash. `SNAPSHOT-REVIEW.json` records that +comparison separately. + +## Mathematical result independently checked + +`independent/independent_operator.py` imports neither construction checker. +It authenticates the original retained fixture data and the complete fresh +cyclic/Pauli receipts. It pulls each final coordinate covector backwards +through the actual chronological word using sparse exact rational arithmetic. +It separately propagates integer vectors divided by powers of two to verify +the executed logical prefixes, private snapshot/readout immutability and +endpoint rows. Full-sweep binary elimination independently checks frame +inclusions and all current/final frame predicates. + +The frozen independent receipt covers fifteen fixtures and thirty orientations: +the rectangle, static and mutable cyclic words for r=2,...,7, and ZERO/radical +Pauli diagnostics. It compares 44,440 ordinary operator coefficients and +22,220 inverse-transpose coefficients. Every ordinary source, target and dirty +helper has a separate input coordinate. The declared final helper values +restore exactly in the logical model. + +Every retained cyclic path, private count/rank, rank histogram/mass, ADD count, +scalar bill and logical prefix bound matches the independent reconstruction. +The Pauli diagnostic coefficients are rebuilt from the actual doubled root +coordinates, and their kernels are independently formed as E E^T/8192. All +four fresh matrices use explicit ordered input-column lists. The latter field +was added following this review to remove the ambiguity caused by JSON key +sorting. + +The independent geometry check regenerates the 120 canonical doubled E8 +lines and verifies an affine factor certificate for the full 14,400-product +label Gram relation. This implies all 207,360,000 ordered label pairings by +bilinearity; it does not claim to iterate that entire square. It independently +reconstructs the selected U15 support span and W2 radical and reduces all +2,400 shared tiling frame records. + +The source review also checked the written factor law, same-order logical +inverse transpose, actual paid refinement chronology and its differential +histograms. The source U insertion and the target/reader join are charged. +W is not contained in the old three-dimensional target arc. The resulting +four-dimensional join explains the extra target and reader events. The +strict static/mutable pressure comparison follows from concavity for the +stated fixed profiles. The Pauli sign and sharing-threshold statements remain +restricted to their exact tested exponents and declared invoice/arity model. + +## Actual defect sensitivity + +The independent checker executes ninety semantic defects after source +authentication, and ninety deletions of the same named production guards. +They cover wrong dirt-ADD signs, missing actual source-frame visits and paid +cancelling ADD pairs. The first changes the operator without changing its +absolute tariff; the last preserves the operator while adding eight component +primitives. Unexpected acceptance is raised outside the rejection handler. + +The construction source was reviewed separately. The cyclic checker matches +the exact intended errors for its retained event omissions and keeps the +redundant r2 marker as a positive control. Its emitted partition and actual +module coefficient mutations use the production predicates. The Pauli +checker executes 28 intended semantic rejections and 28 same-guard deletions, +including the impossible unpaid W-to-old-arc transition and omitted added +reader charge. These do not count generic changed-source hash failures as +mathematical rejection evidence. + +The compact root suite adds 67 intended rejections and 16 named-check +deletions per mode. It exercises real r3 dirty cleanup/frame/cost predicates, +the actual radical Pauli cleanup and W-entry predicates, complete ordered +cross-stage geometry, typed full records, exact stage coverage, compression +bindings, source capture and optimization, and output-path guards. It compares +all three real complete scientific receipts, including deep-field corruption +and omission. These controls are a separate bounded test; they do not rerun +the full producer science stages. + +## Exact source and runtime closure + +The root frozen/origin maps agree on all 56 bound files. This review compared +28 component originals with their historical or pinned-intake bytes, verified +all ten listed Git source blobs against the declared commits, and checked +the fourteen adapted geometry functions by AST equality. Twelve function +bodies are unchanged; two differ only by the declared removal of `m.` +qualification. `SOURCE-CLOSURE.json` records those bindings and the exact +reviewed frozen inventory. + +The cyclic adapter captures and authenticates every original before execution. +It executes six captured modules with `dont_inherit=True,optimize=0`, calls +the five declared historical mains, and uses only the invoked pure functions +from the invoice oracle. All five original receipts are compared by complete +typed projection, with only the disclosed added matrix fields and portable +provenance path normalization. The full K factor and full pairing census +remain pinned inherited evidence; their unrelated programs are not claimed +as freshly executed. + +The fresh Pauli checker executes only captured authenticated `geometry.py`; +historical modules are not imported. The selected TRIPLES assignment is now +required to occur exactly once. Compact controls show that missing and +duplicate selections fail after rebinding only a disposable fixture pin. +No original main/import/search is executed by that literal selection. + +The root verifier sends the exact captured checker bytes to an isolated child +over stdin and explicitly compiles with optimization disabled. The source +controls mutate a disposable source path after capture and confirm that the +captured original executes. Direct, nested child, nested geometry and retained +source assertions remain active under optimized parents. These routes do not +use a normal path importer, so a stale or hostile `.pyc` is not an alternate +source path. Package runtime depends only on Python's standard library. + +The root performs full typed JSON comparison, requires exactly one compared +record for each registered science stage, and reconciles the complete ordered +tiling frame arrays, roots, triples, b-pairs and gauges before and after each +replay. Actual shared-array mutations reject even with the original digest +retained; deleting only that semantic array guard exposes the defect. +Equivalent gzip recompression is accepted after truthful container rebinding, +while the decompressed original digest remains mandatory. + +All replay scratch is external. New outputs use exclusive creation. Relative, +existing and internal wrapper output paths reject before scientific replay. +The final compact controls and their source hashes agree under normal and +optimized outer runs; each run also executes normal and optimized children. + +## Bound validation evidence and limits + +The exact bundled executable used was +`/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3`, +version 3.12.14. The independent scientific normal/optimized receipts and the +normal/optimized compact control receipts were byte-identical. + +| Item | SHA-256 | +| --- | --- | +| Independent checker | `744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382` | +| Independent full receipt, gzip | `40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc` | +| Independent full receipt, raw | `94645c9d913fb182b13cc03f17eb9cad3c056a5a8326c666739914636b8f0393` | +| Compact controls source | `b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de` | +| Compact control receipt | `89c6364cfb3fa73ce1fb3f2c693c8e90a8ff171097e28bf383e88eeb6de2c2ac` | + +The final full matrices and invoices are finite exact computations; the +arbitrary-size factor identity and stated chronology are written proofs under +the declared interfaces. Native admission of degenerate U/W, actual Clifford +phases, raw physical helper return, coefficient temporary states, rounded +precision, physical source access, storage/owner/controller costs and a joint +outer supplier remain unresolved. The large residual stream is specified and +counted rather than emitted or executed. The already-published noncubic-rank +and Smith theorem scopes remain excluded. + +This reviewer did not create a commit, publish a PR, run hosted CI or certify +the parent's later committed/Git-free checks. Those validation/publication +states require their own evidence. diff --git a/research/h6-partial-frame-networks/reviews/SNAPSHOT-REVIEW.json b/research/h6-partial-frame-networks/reviews/SNAPSHOT-REVIEW.json new file mode 100644 index 0000000000..736712eddd --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/SNAPSHOT-REVIEW.json @@ -0,0 +1,11 @@ +{ + "controls_receipt_sha256": "89c6364cfb3fa73ce1fb3f2c693c8e90a8ff171097e28bf383e88eeb6de2c2ac", + "every_declared_byte_and_hash_matches": true, + "outside_snapshot_at_review": [ + "CORE-SNAPSHOT.json" + ], + "reviewed_frozen_manifest_sha256": "73c279f7f25a1e707fe1e3cd42e7d945c6c077d61dd252d54b70a5674361494c", + "snapshot_file_count": 61, + "snapshot_file_sha256": "91102ae9e019a6b725c6960dce1993974a19650f7149790da940cce87c4371db", + "status": "PASS" +} diff --git a/research/h6-partial-frame-networks/reviews/SOURCE-CLOSURE.json b/research/h6-partial-frame-networks/reviews/SOURCE-CLOSURE.json new file mode 100644 index 0000000000..4e58a0095a --- /dev/null +++ b/research/h6-partial-frame-networks/reviews/SOURCE-CLOSURE.json @@ -0,0 +1,404 @@ +{ + "component_original_bindings": [ + { + "binding": "original historical bytes equal", + "original_sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "package_file": "cyclic/frozen/mixed_rectangle.py", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/mixed_rectangle.py" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a", + "package_file": "cyclic/frozen/cyclic_mixed.py", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/cyclic_mixed.py" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "package_file": "cyclic/frozen/dynamic_cyclic.py", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/dynamic_cyclic.py" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "package_file": "cyclic/frozen/module_tiling.py", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/module_tiling.py" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12", + "package_file": "cyclic/frozen/optimistic_budget.py", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/optimistic_budget.py" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7", + "package_file": "cyclic/frozen/EXTENSION.md", + "role": "historical_note_provenance_only", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/EXTENSION.md" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "package_file": "cyclic/frozen/CONTINUATION.md", + "role": "historical_note_provenance_only", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CONTINUATION.md" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "9b9c02dac51d0989148c460f53623d51c6bd1204415991f058c83b77e36e884f", + "package_file": "cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/DYNAMIC-CYCLIC-RESULT.json" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "f65323e4d86d35f1463647ad36bddcffa21dc5eefc6ac4bbcbc8cf0ef4d0c369", + "package_file": "cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CYCLIC-MIXED-RESULT.json" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8", + "package_file": "cyclic/frozen/MIXED-RECTANGLE-RESULT.json", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/MIXED-RECTANGLE-RESULT.json" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590", + "package_file": "cyclic/frozen/MODULE-TILING-RESULT.json", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/MODULE-TILING-RESULT.json" + }, + { + "binding": "original historical bytes equal", + "original_sha256": "699abb5644ebc9ada64b67a6afd14ef9a418fab12a999430ee8296e0016d33db", + "package_file": "cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz", + "role": "historical_original", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/OPTIMISTIC-BUDGET-RESULT.json" + }, + { + "binding": "original pinned Git bytes equal", + "original_sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef", + "package_file": "cyclic/frozen/invoice.py", + "role": "executed_oracle_functions", + "source": "research/h6-independent-audit/invoice/verify.py" + }, + { + "binding": "original pinned Git bytes equal", + "original_sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841", + "package_file": "cyclic/frozen/K-RESULT.json", + "role": "inherited_K_inventory", + "source": "research/h6-compensation-network/k_encoder/RESULT.json" + }, + { + "binding": "original pinned Git bytes equal", + "original_sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454", + "package_file": "cyclic/frozen/pricing.py", + "role": "provenance_only", + "source": "research/h6-compensation-network/pricing/verify.py" + }, + { + "binding": "original pinned Git bytes equal", + "original_sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4", + "package_file": "cyclic/frozen/WALSH-RESULTS.json", + "role": "inherited_all_pairs_receipt", + "source": "research/h6-independent-audit/walsh/results.json" + }, + { + "binding": "original pinned Git bytes equal", + "original_sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "package_file": "cyclic/frozen/e8_cubed.py", + "role": "geometry_provenance", + "source": "research/niemeier-lattices/code/e8_cubed.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "package_file": "pauli/frozen/partial_pauli.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/partial_pauli.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0", + "package_file": "pauli/frozen/PARTIAL-PAULI-RESULT.json", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/PARTIAL-PAULI-RESULT.json" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "package_file": "pauli/frozen/CONTINUATION.md", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/CONTINUATION.md" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "package_file": "pauli/frozen/module_tiling.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/module_tiling.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "package_file": "pauli/frozen/dynamic_cyclic.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/dynamic_cyclic.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "package_file": "pauli/frozen/mixed_rectangle.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/complex-alternative/mixed_rectangle.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad", + "package_file": "pauli/frozen/pauli_partial_review.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/pauli_partial_review.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c", + "package_file": "pauli/frozen/PARTIAL-PAULI-REVIEW.json", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/PARTIAL-PAULI-REVIEW.json" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9", + "package_file": "pauli/frozen/PAULI-FIXED-SUPPORT.json", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/PAULI-FIXED-SUPPORT.json" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55", + "package_file": "pauli/frozen/e8_sections.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/intake/scientific/e8_sections.py" + }, + { + "binding": "original historical/intake bytes equal", + "original_sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "package_file": "pauli/frozen/e8_cubed.py", + "role": "provenance or explicit literal data; original module not executed", + "source": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/intake/scientific/e8_cubed.py" + } + ], + "geometry_function_bindings": [ + { + "change": "none", + "name": "basis", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "canonical_roots", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "cong", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "dot", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "included", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "inv", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "mm", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "need", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "perp", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "symp", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "tr", + "original": "mixed_rectangle.py" + }, + { + "change": "none", + "name": "xor", + "original": "mixed_rectangle.py" + }, + { + "change": "remove m qualification only", + "name": "packed_root_pairs", + "original": "module_tiling.py" + }, + { + "change": "remove m qualification only", + "name": "orthogonal_involution", + "original": "module_tiling.py" + } + ], + "git_blob_bindings": [ + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "path": "certificates/selected-result.json", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "path": "docs/research/agent-task-catalog.json", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "path": "docs/research/research-family-status.md", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "0fb65580f8d88d450be2411a49a507461288e4e8", + "path": "research/h6-independent-audit/invoice/verify.py", + "sha256": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "31368ec6d6eac0d0cb86b0d17c80f07b092d75ff", + "path": "research/h6-compensation-network/k_encoder/RESULT.json", + "sha256": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "f9434ab83e11a4e93d92fdf1b2a9d7f008b41232", + "path": "research/h6-compensation-network/pricing/verify.py", + "sha256": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "4f7a9294c96b6ba69a28527c980f24d696369929", + "path": "research/h6-independent-audit/walsh/results.json", + "sha256": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "d4444d142fb370498bcd9a0abec45e2f5ea0b0c5", + "path": "research/niemeier-lattices/code/e8_cubed.py", + "sha256": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "b9d6fb3a39c330414965601d1aa5faf80f0a36c6", + "path": "research/niemeier-lattices/code/e8_sections.py", + "sha256": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55" + }, + { + "commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "git_blob": "e6dcbd0c683ca877031fdaefd5803f6e4cf5ac78", + "path": "research/niemeier-lattices/NOTICE", + "sha256": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562" + } + ], + "reviewed_root_frozen_file_count": 56, + "reviewed_root_frozen_files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "89a686562a54b7618f4418764d080456cd65d7ab737aa94c7c9faa2aa836e45c", + "SOURCE-AUDIT.md": "3d97ef7b57ec19840445506d8670cc48374b76b53369efab19f4228105699c6e", + "SOURCES.json": "1ec090de5cb3f24ede03b366aacc130bf2f0f785fada4a944d73aa087a7d6be6", + "TASK.json": "bb9cdf900a2b72dbf4bb26c87b3e9328226bc030cc0202df6a8a0ced7c5749e2", + "VERIFY.json": "cd4a861561b7ba5897a55cc1808d3513664b4bdb0d20515b3335cf219b9323a2", + "controls.py": "b7430ed6716b7d9cc3a0b340b6a9234e091c7a53df3c58379989ca6e627bc0de", + "cyclic/CHECKS.json.gz": "d3d514082425e82c8d133921b78b1ae62c158cb963f7059e93df3bd2106255e4", + "cyclic/ORIGINS.json": "e31a8c9f7372d5b3c97bad95a02492ee00f8ebf3e694019ea51bc2c7e7c27617", + "cyclic/OUTPUT-INVENTORY.json": "fc95fed56a591960a14e787ac9438a5eea92dcfa266c22386f7e8db56ebc97fe", + "cyclic/PACKAGE-FILES.json": "1a80361230d10680487b5ec0f23b3dad93cc6e76a6435a2b016665e1b65ea723", + "cyclic/PROOF-CYCLIC.md": "1151cbf936040255969532590ee0c426e7035fc63e3ec7e9ee743031db31c830", + "cyclic/VALIDATION.json": "4b21d22b09ccd1e6e4b7f689e84c25720ad2e4b68feaca59f092b6762029e02c", + "cyclic/check.py": "0a4d71209788476bc6ca8dfda051d2913adcd5fe584ea03be90e04e80123578e", + "cyclic/frozen/CONTINUATION.md": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "cyclic/frozen/CYCLIC-MIXED-RESULT.json.gz": "01ecc1e1011ad69f20a11c350d0e1b41a95ce20ed827ef9a9113159b9d53ff44", + "cyclic/frozen/DYNAMIC-CYCLIC-RESULT.json.gz": "d955d3545dcceb65cb3a3fda32c44e423a5a1169e6accea662d6ee5da6e7ee34", + "cyclic/frozen/EXTENSION.md": "e3856b2872bf51cccb533d1d57111f8e18aada4ae94c7d23034aaff0b78590b7", + "cyclic/frozen/K-RESULT.json": "da53bec0e3a8d027249e5bdfed341bd503d50502ddb63f1777afa5dc97739841", + "cyclic/frozen/MIXED-RECTANGLE-RESULT.json": "fb78f1fe52de77105eee210331b8ba70d733251735ae4855e8c011826ee06ac8", + "cyclic/frozen/MODULE-TILING-RESULT.json": "d84d0ce9bde632b5312072b02814771a66d8e399ec8e394cc3dd8ac8cebf2590", + "cyclic/frozen/OPTIMISTIC-BUDGET-RESULT.json.gz": "ecf3d10f7ae770aab5a00486ddf002d3faea619c1ad0a43de0cc200bf81bbed3", + "cyclic/frozen/WALSH-RESULTS.json": "f2be149a84a424682f756e66c7556aa10b7d9604357a83c79c6b652fe60544d4", + "cyclic/frozen/cyclic_mixed.py": "ae3f62ce0026d5e85120ad6b75569c15fb2e41bae3f849ac7be14b9d9495e51a", + "cyclic/frozen/dynamic_cyclic.py": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "cyclic/frozen/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "cyclic/frozen/invoice.py": "9081aaf27e05c9ce09a3fcb451104c87682114b9759c30680091308f286c44ef", + "cyclic/frozen/mixed_rectangle.py": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "cyclic/frozen/module_tiling.py": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "cyclic/frozen/optimistic_budget.py": "ee7e28eab6bc5b48fa4d646040cf7e0697666d317f22d29404c8c855363ccf12", + "cyclic/frozen/pricing.py": "56f273853bd7089c3721bc023713993ac79e961d535694624cbb60dd7dcdd454", + "independent/CHECKS.json.gz": "40fe76390c36d4c9692f964804359aecfa3ce039b74ef77c909ffbf8a2011ddc", + "independent/INDEPENDENT-INVENTORY.json": "1dd5f8673a3e2069ef7c6b4b5f7f640fe9b61d67a2808e87aabe0f9232f3ccbd", + "independent/PROOF-INDEPENDENT.md": "a933c6f3d89ac3ba648aea33453b6b1789719a5f42fc30b96de92afb38bb86c0", + "independent/independent_operator.py": "744271322bd42775571f462fefe9a8b6cf40a8600a2dbcbfaef27a7b69bc7382", + "notices/niemeier-NOTICE": "a5085b5f46ef649f493cb7447ab3cb4885873e30fa72196e3286e95ed13c9562", + "pauli/CHECKS.json.gz": "8e87b99cbab046151357691f7b891f25daf4aba5f2ad6c6bedda3342d003bce4", + "pauli/ORIGINS.json": "b4235680bf13f22e9bc408f074ad704b860dfee965876dfd005c4155d2d22382", + "pauli/OUTPUT-INVENTORY.json": "e298c71472382495463ff06cb423458c2c96fd7644dd87910ace3a687c7d3987", + "pauli/PACKAGE-FILES.json": "de43b271434680161972186463a7e57e8e9c20a230431c129fe393d268cc1fe4", + "pauli/PROOF.md": "74e81020d348b57f21bb857ce25f1d68efd822d6c7a4e1e97219d80f1eb8ed9c", + "pauli/VALIDATION.json": "da0f04c3415a432c6c235983789e6911bee467ab5dde80475d24e47e93e89184", + "pauli/check.py": "97b97531bd312ccae4da4ce2e7a767f32c749db2eb7408eb38b517699f970a66", + "pauli/frozen/CONTINUATION.md": "7ba7f0806ea9d35912f736864d3e7696314e075faac6a6bb979789cb765151df", + "pauli/frozen/PARTIAL-PAULI-RESULT.json": "048830fbb42141a07a946fc3e32f5c666100a5265a69db5600c432595bb364d0", + "pauli/frozen/PARTIAL-PAULI-REVIEW.json": "0a56ac6aedc39787ef228a14354741077c44df2b33d174765a8c4478ee84301c", + "pauli/frozen/PAULI-FIXED-SUPPORT.json": "344af488229ebc64485132bf316813c4242ddaee35a2ea5878a10b2fc5d671b9", + "pauli/frozen/dynamic_cyclic.py": "8b97368264eff933191b05d80c78c3c72cb7d23b810303d085b194240dd818df", + "pauli/frozen/e8_cubed.py": "ce24f397053c0ef5b26881bb7ccfab53fb0a3d762f2de04086fed8f7b41e8234", + "pauli/frozen/e8_sections.py": "19b05280ad59f2938c2c9a4ffef213712a65af75d7c111fa304fdc2868d13f55", + "pauli/frozen/mixed_rectangle.py": "544d6b7d4ea92134b1016ce359f01b7a33ebb2ba0d986bf5b9accc47a3ec600c", + "pauli/frozen/module_tiling.py": "c7ea13441daabed63860e8ae464293f4a16af20be331941fc8edd12412e8d73d", + "pauli/frozen/partial_pauli.py": "774d876402be6066121a982f0c149b924b53c72bc53f6bfd13d96f751600b8bd", + "pauli/frozen/pauli_partial_review.py": "01d5a2e002545de95823b220be73debc298a73c7f96ac4d4b0486e1cb578efad", + "pauli/geometry.py": "05d23eeb09cd04785b28d5337f0c2e19de3bf1cd7e54a26c219cb10c9a3daf25", + "verify.py": "db07043a36beac98813b35a9380cb2799dd0507348ab4aa62200ce65f9513c1b" + }, + "runtime_execution": { + "ambient_dependencies": "Python standard library only; no runtime Git, NumPy, repository source path, importlib source loader or pyc route.", + "cyclic": "Six captured modules, five explicitly called historical mains; invoice only invoked pure functions. All original receipt fields compared by typed projection.", + "independent": "No producer execution; exact retained/fresh receipt inputs and distinct algebraic representations.", + "pauli": "Fresh checker and captured geometry; historical source not imported; unique literal TRIPLES selection.", + "root": "Captured authenticated source on stdin; isolated child; compile dont_inherit=True optimize=0" + }, + "schema": "c03_source_closure.v1", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Current source closure and original-byte bindings. Additional review outputs are bound by the final core snapshot, not recursively by this record.", + "status": "PASS" +} diff --git a/research/h6-partial-frame-networks/verify.py b/research/h6-partial-frame-networks/verify.py new file mode 100644 index 0000000000..3d47979472 --- /dev/null +++ b/research/h6-partial-frame-networks/verify.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +"""Authenticate and replay the H6 partial-frame logical network package. + +Ross Richardson with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import gzip +import hashlib +import json +from pathlib import Path, PurePosixPath +import subprocess +import sys +import tempfile + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def unique_object(pairs): + result = {} + for key, value in pairs: + require(key not in result, "duplicate JSON key: " + key) + result[key] = value + return result + + +def invalid_constant(value): + raise ValueError("nonfinite JSON constant: " + value) + + +def decoded(raw): + return gzip.decompress(raw) if raw.startswith(b"\x1f\x8b") else raw + + +def data(raw): + return json.loads(decoded(raw), object_pairs_hook=unique_object, + parse_constant=invalid_constant) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), + ensure_ascii=False, allow_nan=False) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +class Frozen: + def __init__(self, root): + self.root = Path(root).resolve() + self.hashes = data((self.root / "FROZEN-SHA256.json").read_bytes()) + self.origins = data((self.root / "ORIGINS.json").read_bytes()) + self.compared = [] + + def path(self, name): + parts = PurePosixPath(name) + require(not parts.is_absolute() and ".." not in parts.parts, + "unsafe package path") + path = self.root / name + require(path.is_file() and not path.is_symlink(), "missing regular input: " + name) + require(path.resolve().is_relative_to(self.root), "input escapes package") + return path + + def raw(self, name): + require(name in self.hashes, "unregistered input: " + name) + raw = self.path(name).read_bytes() + require(digest(raw) == self.hashes[name], "changed frozen input: " + name) + return raw + + def check_all(self): + require(set(self.origins) == set(self.hashes), "frozen/origin inventory mismatch") + for name in self.hashes: + raw = self.raw(name) + origin = self.origins[name] + require(origin["sha256"] == digest(raw), "origin digest mismatch: " + name) + if "original_sha256" in origin: + require(digest(decoded(raw)) == origin["original_sha256"], + "original decoded bytes changed: " + name) + + def compare(self, expected, generated): + require(canonical(data(self.raw(expected))) == canonical(data(generated)), + "complete typed record mismatch: " + expected) + self.compared.append(expected) + + def run(self, script, arguments): + source = self.raw(script) + bootstrap = ( + "import sys\n" + "source = sys.stdin.buffer.read()\n" + "sys.argv = sys.argv[1:]\n" + "namespace = {'__name__': '__main__', '__file__': sys.argv[0]}\n" + "exec(compile(source, sys.argv[0], 'exec', dont_inherit=True, optimize=0), namespace)\n" + ) + completed = subprocess.run( + [sys.executable, "-I", "-B", "-c", bootstrap, + str(self.path(script)), *map(str, arguments)], + cwd=self.root, input=source, capture_output=True, check=False) + require(completed.returncode == 0, + "checker failed: " + script + "\n" + + completed.stdout.decode(errors="replace") + + completed.stderr.decode(errors="replace")) + + +STAGES = { + "cyclic": ("cyclic/check.py", "cyclic/CHECKS.json.gz"), + "pauli": ("pauli/check.py", "pauli/CHECKS.json.gz"), + "independent": ("independent/independent_operator.py", "independent/CHECKS.json.gz"), +} + + +def expected_records(stage): + return {STAGES[stage][1]} + + +def check_coverage(stage, compared): + expected = expected_records(stage) + require(set(compared) == expected and len(compared) == len(expected), + "complete stage record coverage changed: " + stage) + + +def check_contracts(frozen): + cyclic = data(frozen.raw("cyclic/CHECKS.json.gz")) + pauli = data(frozen.raw("pauli/CHECKS.json.gz")) + left = cyclic["complete_tiling"]["frame_cases"] + right = pauli["tiling_frame_cases"] + require(len(left) == len(right) == 2400, "complete tiling frame count") + require(canonical(left) == canonical(right), "complete tiling frame arrays differ") + require(digest(canonical(left).encode()) == pauli["tiling_frame_cases_sha256"], + "complete tiling frame digest mismatch") + tiled = cyclic["reports"]["MODULE-TILING-RESULT.json"] + for key, pauli_key in (("canonical_roots", "canonical_roots"), + ("a_triples", "tiling_a_triples"), + ("b_orthogonal_involution_pairs", "tiling_b_pairs"), + ("triple_gauge_signs", "tiling_gauge_signs")): + require(canonical(tiled[key]) == canonical(pauli[pauli_key]), + "complete shared geometry differs: " + key) + return {"frame_cases": len(left), + "frame_cases_sha256": digest(canonical(left).encode())} + + +def replay(frozen, scratch, stage): + script, expected = STAGES[stage] + output = scratch / (stage + ".json") + arguments = ["--output", output] + if stage == "independent": + arguments.extend(["--source-dir", frozen.root / "cyclic/frozen"]) + for name in ("cyclic", "pauli"): + receipt = name + "/CHECKS.json.gz" + arguments.extend(["--" + name + "-receipt", frozen.root / receipt, + "--" + name + "-sha256", digest(frozen.raw(receipt))]) + frozen.run(script, arguments) + frozen.compare(expected, output.read_bytes()) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--stage", required=True, choices=tuple(STAGES)) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + root = Path(__file__).resolve().parent + if args.output is not None: + require(args.output.is_absolute(), "output must be absolute") + require(not args.output.exists(), "output already exists") + require(not args.output.resolve().is_relative_to(root), "output must be external") + frozen = Frozen(root) + frozen.check_all() + contracts = check_contracts(frozen) + with tempfile.TemporaryDirectory(prefix="H6 partial frame replay ") as directory: + replay(frozen, Path(directory), args.stage) + check_coverage(args.stage, frozen.compared) + require(check_contracts(frozen) == contracts, "contracts changed during replay") + frozen.check_all() + result = {"status": "PASS_H6_PARTIAL_FRAME_" + args.stage.upper(), + "compared": sorted(frozen.compared), "shared_geometry": contracts, + "no_new_kappa": True} + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.output is not None: + with args.output.open("x") as destination: + destination.write(encoded) + print(encoded, end="") + + +if __name__ == "__main__": + main()