From e7d797371f634b03758dfac8fb9757f05eb6dca5 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:53:08 +1100 Subject: [PATCH] Separate immutable native headers from DATA-only HOME fields with complete fixed-tape return --- .../CHECKSUMS.sha256 | 80 + .../FREEZE.json | 418 ++++ .../PACKAGING-CHECKS.json | 10 + .../PR-DESCRIPTION.md | 72 + .../PR-TITLE.txt | 1 + .../PUBLICATION-MANIFEST.json | 480 +++++ .../borrowed-header-data-only-home/README.md | 140 ++ .../REGISTERED-metadata.stderr | 0 .../REGISTERED-metadata.stdout | 1 + .../REGISTERED-registered.stderr | 0 .../REGISTERED-registered.stdout | 58 + .../REVIEW-STATUS.json | 26 + .../SOURCES.json | 154 ++ .../borrowed-header-data-only-home/TASK.json | 93 + .../VALIDATION.json | 33 + .../VERIFY.json | 74 + .../implementation/CHECKPOINT.json | 42 + .../implementation/CHECKSUMS | 50 + .../implementation/FREEZE.json | 259 +++ .../implementation/GRAPH.json | 29 + .../implementation/NOTICE.md | 20 + .../implementation/PR-DRAFT.md | 26 + .../implementation/PREFLIGHT.md | 36 + .../implementation/PROOF.md | 218 +++ .../implementation/README.md | 40 + .../implementation/RESULT.json | 339 ++++ .../implementation/SOURCES.json | 290 +++ .../implementation/adapter.py | 140 ++ .../implementation/inputs/core/CHECKPOINT.md | 18 + .../inputs/core/ENVIRONMENT.json | 9 + .../implementation/inputs/core/FREEZE.json | 191 ++ .../implementation/inputs/core/NOTICE.md | 30 + .../implementation/inputs/core/OVERLAP.md | 46 + .../inputs/core/PR-DESCRIPTION.md | 38 + .../implementation/inputs/core/PROOF.md | 219 +++ .../implementation/inputs/core/README.md | 57 + .../implementation/inputs/core/RESULT.json | 1722 +++++++++++++++++ .../inputs/core/SOURCE-BINDING.json | 65 + .../implementation/inputs/core/SOURCES.json | 143 ++ .../implementation/inputs/core/adapter.py | 117 ++ .../inputs/core/bind_sources.py | 61 + .../implementation/inputs/core/join.py | 159 ++ .../implementation/inputs/core/machine.py | 129 ++ .../inputs/core/reference/pr6978-PROOF.md | 380 ++++ .../inputs/core/reference/rank2/FREEZE.json | 179 ++ .../inputs/core/reference/rank2/PROOF.md | 316 +++ .../inputs/core/reference/rank2/RECIPE.json | 490 +++++ .../inputs/core/reference/rank2/SOURCES.json | 232 +++ .../inputs/core/reference/rank2/machine.py | 129 ++ .../inputs/core/reference/rank2/rank2.py | 200 ++ .../reference/rank2/reference/home/NOTICE.md | 35 + .../rank2/reference/home/parent_adapter.py | 131 ++ .../rank2/reference/home/tape_graph.py | 281 +++ .../reference/rank2/reference/leaf/NOTICE.md | 34 + .../leaf/inputs/controller_reference.py | 112 ++ .../reference/rank2/reference/leaf/leaf.py | 564 ++++++ .../rank2/reference/linear/NOTICE.md | 36 + .../linear/inputs/controller_reference.py | 112 ++ .../rank2/reference/linear/linear.py | 435 +++++ .../reference/rank2/reference/phase/NOTICE | 11 + .../phase/inputs/controller_reference.py | 112 ++ .../reference/rank2/reference/phase/phase.py | 335 ++++ .../rank2/reference/source/clifford_exact.py | 149 ++ .../rank2/reference/source/native_verify.py | 277 +++ .../implementation/inputs/core/verify.py | 209 ++ .../implementation/machine.py | 129 ++ .../implementation/verify.py | 112 ++ .../review/interface/PORTABILITY.json | 11 + .../review/interface/RESULT.json | 33 + .../review/interface/REVIEW.md | 106 + .../review/interface/check_review.py | 171 ++ .../review/interface/original/CHECKPOINT.md | 17 + .../review/interface/original/MANIFEST.json | 27 + .../review/interface/original/RESULT.json | 33 + .../review/interface/original/REVIEW.md | 106 + .../review/interface/original/check_review.py | 167 ++ .../review/packaging/BASE-FREEZE.json | 406 ++++ .../review/packaging/INTEGRATION-NOTE.md | 3 + .../review/root/RESULT.json | 48 + .../review/root/ROOT-REVIEW.md | 79 + .../review/root/check_borrowed_root.py | 116 ++ 81 files changed, 12456 insertions(+) create mode 100644 research/borrowed-header-data-only-home/CHECKSUMS.sha256 create mode 100644 research/borrowed-header-data-only-home/FREEZE.json create mode 100644 research/borrowed-header-data-only-home/PACKAGING-CHECKS.json create mode 100644 research/borrowed-header-data-only-home/PR-DESCRIPTION.md create mode 100644 research/borrowed-header-data-only-home/PR-TITLE.txt create mode 100644 research/borrowed-header-data-only-home/PUBLICATION-MANIFEST.json create mode 100644 research/borrowed-header-data-only-home/README.md create mode 100644 research/borrowed-header-data-only-home/REGISTERED-metadata.stderr create mode 100644 research/borrowed-header-data-only-home/REGISTERED-metadata.stdout create mode 100644 research/borrowed-header-data-only-home/REGISTERED-registered.stderr create mode 100644 research/borrowed-header-data-only-home/REGISTERED-registered.stdout create mode 100644 research/borrowed-header-data-only-home/REVIEW-STATUS.json create mode 100644 research/borrowed-header-data-only-home/SOURCES.json create mode 100644 research/borrowed-header-data-only-home/TASK.json create mode 100644 research/borrowed-header-data-only-home/VALIDATION.json create mode 100644 research/borrowed-header-data-only-home/VERIFY.json create mode 100644 research/borrowed-header-data-only-home/implementation/CHECKPOINT.json create mode 100644 research/borrowed-header-data-only-home/implementation/CHECKSUMS create mode 100644 research/borrowed-header-data-only-home/implementation/FREEZE.json create mode 100644 research/borrowed-header-data-only-home/implementation/GRAPH.json create mode 100644 research/borrowed-header-data-only-home/implementation/NOTICE.md create mode 100644 research/borrowed-header-data-only-home/implementation/PR-DRAFT.md create mode 100644 research/borrowed-header-data-only-home/implementation/PREFLIGHT.md create mode 100644 research/borrowed-header-data-only-home/implementation/PROOF.md create mode 100644 research/borrowed-header-data-only-home/implementation/README.md create mode 100644 research/borrowed-header-data-only-home/implementation/RESULT.json create mode 100644 research/borrowed-header-data-only-home/implementation/SOURCES.json create mode 100644 research/borrowed-header-data-only-home/implementation/adapter.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/CHECKPOINT.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/ENVIRONMENT.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/FREEZE.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/NOTICE.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/OVERLAP.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/PR-DESCRIPTION.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/PROOF.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/README.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/RESULT.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/SOURCE-BINDING.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/SOURCES.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/adapter.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/bind_sources.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/join.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/machine.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/pr6978-PROOF.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/FREEZE.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/PROOF.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/RECIPE.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/SOURCES.json create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/machine.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/rank2.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/home/NOTICE.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/home/parent_adapter.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/home/tape_graph.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/leaf.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/linear.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/NOTICE create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/phase.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/source/native_verify.py create mode 100644 research/borrowed-header-data-only-home/implementation/inputs/core/verify.py create mode 100644 research/borrowed-header-data-only-home/implementation/machine.py create mode 100644 research/borrowed-header-data-only-home/implementation/verify.py create mode 100644 research/borrowed-header-data-only-home/review/interface/PORTABILITY.json create mode 100644 research/borrowed-header-data-only-home/review/interface/RESULT.json create mode 100644 research/borrowed-header-data-only-home/review/interface/REVIEW.md create mode 100644 research/borrowed-header-data-only-home/review/interface/check_review.py create mode 100644 research/borrowed-header-data-only-home/review/interface/original/CHECKPOINT.md create mode 100644 research/borrowed-header-data-only-home/review/interface/original/MANIFEST.json create mode 100644 research/borrowed-header-data-only-home/review/interface/original/RESULT.json create mode 100644 research/borrowed-header-data-only-home/review/interface/original/REVIEW.md create mode 100644 research/borrowed-header-data-only-home/review/interface/original/check_review.py create mode 100644 research/borrowed-header-data-only-home/review/packaging/BASE-FREEZE.json create mode 100644 research/borrowed-header-data-only-home/review/packaging/INTEGRATION-NOTE.md create mode 100644 research/borrowed-header-data-only-home/review/root/RESULT.json create mode 100644 research/borrowed-header-data-only-home/review/root/ROOT-REVIEW.md create mode 100644 research/borrowed-header-data-only-home/review/root/check_borrowed_root.py diff --git a/research/borrowed-header-data-only-home/CHECKSUMS.sha256 b/research/borrowed-header-data-only-home/CHECKSUMS.sha256 new file mode 100644 index 0000000000..e5fe90fe84 --- /dev/null +++ b/research/borrowed-header-data-only-home/CHECKSUMS.sha256 @@ -0,0 +1,80 @@ +cd72a820418c73557b75c3392547ce0d45786209462aad322479bf0ce6f17186 FREEZE.json +687858f9cda0cf26081ae56164dc4036ff95337a8c7618c041d74336ced76ca8 PACKAGING-CHECKS.json +d0cc173e9ce04e6e1aa26391edc37fa5f3e443e1cc434bd39410c8f4fd9a5dc7 PR-DESCRIPTION.md +6262878905310be0e87ed2eb44bfbd0ab5f902ef502deeaad50a99025b15e172 PR-TITLE.txt +a5b1b94b0a3a7b28232bce2853377c46057d7168e7771ebe37be376f30d2db50 PUBLICATION-MANIFEST.json +4997af62940ba66bd8061af54f55e80d012b4ea4eaeeabb79b5eb707e39595ee README.md +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 REGISTERED-metadata.stderr +5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647 REGISTERED-metadata.stdout +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 REGISTERED-registered.stderr +91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f REGISTERED-registered.stdout +11aa4289474af475d0b13fa2351d7a279ab138508cbe5cfef1b168b38105a9bc REVIEW-STATUS.json +b3d12097e54d9b9fdb6f8479048cda60eb806e8bf56813f2c1ff9f1ade742a44 SOURCES.json +33ec6c87bd099f0b0618b867e946e0741fbeacc3eaa6d95a640668238e46aa37 TASK.json +1f8c42e4dc3d5a22a92985bc33c285052a72e45e5f2acf00fa60a54bd7cc4057 VALIDATION.json +97956d6f762f64c906ece40d1072fc16c7aae6c65b73caf5fa7fc8e20ed89456 VERIFY.json +eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500 implementation/CHECKPOINT.json +1466b78b44ccd6f965bcd93cfff57bdff9de19bef38cca6de1139a4be08534cf implementation/CHECKSUMS +0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7 implementation/FREEZE.json +2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b implementation/GRAPH.json +38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040 implementation/NOTICE.md +80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482 implementation/PR-DRAFT.md +7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef implementation/PREFLIGHT.md +667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744 implementation/PROOF.md +5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3 implementation/README.md +143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3 implementation/RESULT.json +2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5 implementation/SOURCES.json +182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14 implementation/adapter.py +ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa implementation/inputs/core/CHECKPOINT.md +77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b implementation/inputs/core/ENVIRONMENT.json +5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef implementation/inputs/core/FREEZE.json +4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940 implementation/inputs/core/NOTICE.md +d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c implementation/inputs/core/OVERLAP.md +794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885 implementation/inputs/core/PR-DESCRIPTION.md +48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb implementation/inputs/core/PROOF.md +7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c implementation/inputs/core/README.md +95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3 implementation/inputs/core/RESULT.json +ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232 implementation/inputs/core/SOURCE-BINDING.json +496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03 implementation/inputs/core/SOURCES.json +e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534 implementation/inputs/core/adapter.py +c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6 implementation/inputs/core/bind_sources.py +971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6 implementation/inputs/core/join.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee implementation/inputs/core/machine.py +2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d implementation/inputs/core/reference/pr6978-PROOF.md +072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275 implementation/inputs/core/reference/rank2/FREEZE.json +93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352 implementation/inputs/core/reference/rank2/PROOF.md +b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702 implementation/inputs/core/reference/rank2/RECIPE.json +659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641 implementation/inputs/core/reference/rank2/SOURCES.json +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee implementation/inputs/core/reference/rank2/machine.py +3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a implementation/inputs/core/reference/rank2/rank2.py +b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842 implementation/inputs/core/reference/rank2/reference/home/NOTICE.md +04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099 implementation/inputs/core/reference/rank2/reference/home/parent_adapter.py +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 implementation/inputs/core/reference/rank2/reference/home/tape_graph.py +773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py +bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744 implementation/inputs/core/reference/rank2/reference/leaf/leaf.py +2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50 implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py +d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33 implementation/inputs/core/reference/rank2/reference/linear/linear.py +5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0 implementation/inputs/core/reference/rank2/reference/phase/NOTICE +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py +2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7 implementation/inputs/core/reference/rank2/reference/phase/phase.py +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 implementation/inputs/core/reference/rank2/reference/source/native_verify.py +b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471 implementation/inputs/core/verify.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee implementation/machine.py +54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4 implementation/verify.py +90f6b2fd89c1ae65e8e5d82b77f8901025bce9599bde6b8d93e99fa3a024f911 review/interface/PORTABILITY.json +5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5 review/interface/RESULT.json +64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26 review/interface/REVIEW.md +d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb review/interface/check_review.py +76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495 review/interface/original/CHECKPOINT.md +ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f review/interface/original/MANIFEST.json +5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5 review/interface/original/RESULT.json +64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26 review/interface/original/REVIEW.md +84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590 review/interface/original/check_review.py +bd7c82f6b63d116cab55761933f2941613e28f98b652945dd487152db53c261b review/packaging/BASE-FREEZE.json +ba087d28b7b07f46f6a5ebcccea39c3f126eff56dbf9be35deffad1aa8f81625 review/packaging/INTEGRATION-NOTE.md +3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502 review/root/RESULT.json +88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6 review/root/ROOT-REVIEW.md +98e8991f6e85692dc523dab5479e2094072377f3cfbefe443959f3ce68013a2e review/root/check_borrowed_root.py diff --git a/research/borrowed-header-data-only-home/FREEZE.json b/research/borrowed-header-data-only-home/FREEZE.json new file mode 100644 index 0000000000..887a7e138e --- /dev/null +++ b/research/borrowed-header-data-only-home/FREEZE.json @@ -0,0 +1,418 @@ +{ + "schema": "borrowed-header-publication-freeze/1", + "status": "FROZEN_FOR_ROOT_PUBLICATION", + "utc": "2026-11-13 14:50 UTC", + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "author_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "generic_core_freeze_sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "root_review_sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6", + "interface_original_manifest_sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f", + "registered_commands_passed": 5, + "metadata_and_source_pins": "PASS", + "files": [ + { + "path": "PACKAGING-CHECKS.json", + "bytes": 667, + "sha256": "687858f9cda0cf26081ae56164dc4036ff95337a8c7618c041d74336ced76ca8" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 4824, + "sha256": "d0cc173e9ce04e6e1aa26391edc37fa5f3e443e1cc434bd39410c8f4fd9a5dc7" + }, + { + "path": "PR-TITLE.txt", + "bytes": 97, + "sha256": "6262878905310be0e87ed2eb44bfbd0ab5f902ef502deeaad50a99025b15e172" + }, + { + "path": "README.md", + "bytes": 8073, + "sha256": "4997af62940ba66bd8061af54f55e80d012b4ea4eaeeabb79b5eb707e39595ee" + }, + { + "path": "REGISTERED-metadata.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "REGISTERED-metadata.stdout", + "bytes": 69, + "sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647" + }, + { + "path": "REGISTERED-registered.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "REGISTERED-registered.stdout", + "bytes": 4366, + "sha256": "91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f" + }, + { + "path": "REVIEW-STATUS.json", + "bytes": 1122, + "sha256": "11aa4289474af475d0b13fa2351d7a279ab138508cbe5cfef1b168b38105a9bc" + }, + { + "path": "SOURCES.json", + "bytes": 5703, + "sha256": "b3d12097e54d9b9fdb6f8479048cda60eb806e8bf56813f2c1ff9f1ade742a44" + }, + { + "path": "TASK.json", + "bytes": 7276, + "sha256": "33ec6c87bd099f0b0618b867e946e0741fbeacc3eaa6d95a640668238e46aa37" + }, + { + "path": "VALIDATION.json", + "bytes": 1365, + "sha256": "1f8c42e4dc3d5a22a92985bc33c285052a72e45e5f2acf00fa60a54bd7cc4057" + }, + { + "path": "VERIFY.json", + "bytes": 2882, + "sha256": "97956d6f762f64c906ece40d1072fc16c7aae6c65b73caf5fa7fc8e20ed89456" + }, + { + "path": "implementation/CHECKPOINT.json", + "bytes": 1928, + "sha256": "eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500" + }, + { + "path": "implementation/CHECKSUMS", + "bytes": 4955, + "sha256": "1466b78b44ccd6f965bcd93cfff57bdff9de19bef38cca6de1139a4be08534cf" + }, + { + "path": "implementation/FREEZE.json", + "bytes": 8658, + "sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7" + }, + { + "path": "implementation/GRAPH.json", + "bytes": 881, + "sha256": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b" + }, + { + "path": "implementation/NOTICE.md", + "bytes": 1174, + "sha256": "38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040" + }, + { + "path": "implementation/PR-DRAFT.md", + "bytes": 1520, + "sha256": "80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482" + }, + { + "path": "implementation/PREFLIGHT.md", + "bytes": 2329, + "sha256": "7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef" + }, + { + "path": "implementation/PROOF.md", + "bytes": 12966, + "sha256": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744" + }, + { + "path": "implementation/README.md", + "bytes": 1959, + "sha256": "5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3" + }, + { + "path": "implementation/RESULT.json", + "bytes": 4081, + "sha256": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3" + }, + { + "path": "implementation/SOURCES.json", + "bytes": 12887, + "sha256": "2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5" + }, + { + "path": "implementation/adapter.py", + "bytes": 6086, + "sha256": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14" + }, + { + "path": "implementation/inputs/core/CHECKPOINT.md", + "bytes": 1877, + "sha256": "ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa" + }, + { + "path": "implementation/inputs/core/ENVIRONMENT.json", + "bytes": 468, + "sha256": "77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b" + }, + { + "path": "implementation/inputs/core/FREEZE.json", + "bytes": 6301, + "sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef" + }, + { + "path": "implementation/inputs/core/NOTICE.md", + "bytes": 1756, + "sha256": "4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940" + }, + { + "path": "implementation/inputs/core/OVERLAP.md", + "bytes": 2859, + "sha256": "d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c" + }, + { + "path": "implementation/inputs/core/PR-DESCRIPTION.md", + "bytes": 2398, + "sha256": "794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885" + }, + { + "path": "implementation/inputs/core/PROOF.md", + "bytes": 12196, + "sha256": "48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb" + }, + { + "path": "implementation/inputs/core/README.md", + "bytes": 3479, + "sha256": "7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c" + }, + { + "path": "implementation/inputs/core/RESULT.json", + "bytes": 28741, + "sha256": "95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3" + }, + { + "path": "implementation/inputs/core/SOURCE-BINDING.json", + "bytes": 1772, + "sha256": "ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232" + }, + { + "path": "implementation/inputs/core/SOURCES.json", + "bytes": 5445, + "sha256": "496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03" + }, + { + "path": "implementation/inputs/core/adapter.py", + "bytes": 4845, + "sha256": "e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534" + }, + { + "path": "implementation/inputs/core/bind_sources.py", + "bytes": 2850, + "sha256": "c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6" + }, + { + "path": "implementation/inputs/core/join.py", + "bytes": 6778, + "sha256": "971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6" + }, + { + "path": "implementation/inputs/core/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/inputs/core/reference/pr6978-PROOF.md", + "bytes": 20312, + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d" + }, + { + "path": "implementation/inputs/core/reference/rank2/FREEZE.json", + "bytes": 5633, + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275" + }, + { + "path": "implementation/inputs/core/reference/rank2/PROOF.md", + "bytes": 16634, + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352" + }, + { + "path": "implementation/inputs/core/reference/rank2/RECIPE.json", + "bytes": 4468, + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + }, + { + "path": "implementation/inputs/core/reference/rank2/SOURCES.json", + "bytes": 10337, + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641" + }, + { + "path": "implementation/inputs/core/reference/rank2/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/inputs/core/reference/rank2/rank2.py", + "bytes": 8253, + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "implementation/inputs/core/verify.py", + "bytes": 9469, + "sha256": "b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471" + }, + { + "path": "implementation/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/verify.py", + "bytes": 7746, + "sha256": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4" + }, + { + "path": "review/interface/PORTABILITY.json", + "bytes": 745, + "sha256": "90f6b2fd89c1ae65e8e5d82b77f8901025bce9599bde6b8d93e99fa3a024f911" + }, + { + "path": "review/interface/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/check_review.py", + "bytes": 9363, + "sha256": "d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb" + }, + { + "path": "review/interface/original/CHECKPOINT.md", + "bytes": 1125, + "sha256": "76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495" + }, + { + "path": "review/interface/original/MANIFEST.json", + "bytes": 826, + "sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f" + }, + { + "path": "review/interface/original/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/original/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/original/check_review.py", + "bytes": 9157, + "sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590" + }, + { + "path": "review/packaging/BASE-FREEZE.json", + "bytes": 14556, + "sha256": "bd7c82f6b63d116cab55761933f2941613e28f98b652945dd487152db53c261b" + }, + { + "path": "review/packaging/INTEGRATION-NOTE.md", + "bytes": 419, + "sha256": "ba087d28b7b07f46f6a5ebcccea39c3f126eff56dbf9be35deffad1aa8f81625" + }, + { + "path": "review/root/RESULT.json", + "bytes": 1360, + "sha256": "3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502" + }, + { + "path": "review/root/ROOT-REVIEW.md", + "bytes": 4608, + "sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6" + }, + { + "path": "review/root/check_borrowed_root.py", + "bytes": 7464, + "sha256": "98e8991f6e85692dc523dab5479e2094072377f3cfbefe443959f3ce68013a2e" + } + ], + "excluded_paths": [ + "FREEZE.json(self)", + "PUBLICATION-MANIFEST.json", + "CHECKSUMS.sha256" + ], + "original_author_unchanged": true, + "root_and_original_interface_review_bytes_unchanged": true, + "portable_interface_adaptation": "Only CLI subject and read-only receipt comparison; elapsed_seconds alone excluded. See review/interface/PORTABILITY.json.", + "known_defects": [], + "scope": "Supplied immutable Gamma6 HEADER plus already-packed DATA-only HOME; no root producer/view/cutoff-policy/caller/nonleaf or kappa claim.", + "validation_global_mutated": false, + "remote_publication_performed": false, + "base_packaging_freeze_sha256": "bd7c82f6b63d116cab55761933f2941613e28f98b652945dd487152db53c261b", + "root_integration": "Outer PR-description provenance/reproduction only; all scientific bytes unchanged." +} diff --git a/research/borrowed-header-data-only-home/PACKAGING-CHECKS.json b/research/borrowed-header-data-only-home/PACKAGING-CHECKS.json new file mode 100644 index 0000000000..453c85ea06 --- /dev/null +++ b/research/borrowed-header-data-only-home/PACKAGING-CHECKS.json @@ -0,0 +1,10 @@ +{ + "status": "metadata_pass", + "returncode": 0, + "stdout": "PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)\n", + "stderr": "", + "method": "Unchanged official registered validator in a temporary copied publication overlay. Git provenance reads use canonical stored objects with GIT_NO_LAZY_FETCH=1; no shared worktree/source was edited. No input files are declared outside this self-contained package.", + "outer_freeze": "Final status is VALIDATION.json and FREEZE.json.", + "author_FREEZE_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "stage": "Earlier metadata-only preflight, before review integration" +} diff --git a/research/borrowed-header-data-only-home/PR-DESCRIPTION.md b/research/borrowed-header-data-only-home/PR-DESCRIPTION.md new file mode 100644 index 0000000000..bf635def1a --- /dev/null +++ b/research/borrowed-header-data-only-home/PR-DESCRIPTION.md @@ -0,0 +1,72 @@ +## Result + +Inline Gamma6/HOME adapters tie scientific field extent to E+V. Add a +literal fixed-rho wrapper with a separate supplied immutable Gamma6 HEADER +and DATA-only HOME of extent V, independent of encoded header length E. +It embeds the frozen positive native core unchanged, checks the returned +DATA extent and retires all private/head/guard state before the same-owner +B1 scatter. No native DATA padding or changed f is introduced. + +For fixed rho1..9 the full nine-slot geometry, spectators, coefficients, +positive phase and actual rank-times-f guard remain. Every C-prefix must +be integral and fit. A single-header graph uses34 fixed tapes; the two-header +reuse fixture uses35. Entry is already-reserved B1 execution_start; the +original unreachable reservation prefix does not execute on HEADER3. The +constructor checks reachable borrowed-header immutability. + +Complete local bounds retain the actual core and historical backing: + +```text +T <= Setup_rho + 256(V+1) + 2^24(fV+E+1) +K_final <= K_entry + 2112(V+E+1) +``` + +B1 delivery/reservation and all older/exterior storage remain separate. +E still contributes to core time/history while F_HOME=V remains independent. + +Author normal/optimized replays pass: two complete6144-bit f1/rho1 calls +reuse the same HOME and native banks with E10/E268 immutable headers supplied +at entry (cutoff bit lengths1/130). Exact C squared swap,2452104 transitions, +12288 HOME writes, zero HEADER writes. Controls cover actual cutoff, +short DATA and late arithmetic rejection before HOME mutation, plus emitted +return-extent/wrong-home/unfinished scatter faults. Guard test monitoring is +not compiled protection. + +A separate root sparse CPU and closed Gaussian Hamming kernel pass a fresh +rank2 f1,S2,w7 packet, V14336,E270,130-bit cutoff and immediate opaque HEADER +suffix:13698674 transitions,14336 late HOME writes, zero HEADER writes, +all34 heads/private/guards/exteriors restored. It checks all25242 injected +core instructions and every reachable state; header reads stop at cell270. +The numerical fixture/oracle and interpreter are separate from the author. + +A's separate proof/interface review also passes. Its direct-PC checker +compares1373214 instructions for all nine ranks/header3,34. A fresh sparse +CPU executes three same-HOME rho2 services at signed origins with +E12/12308>V6144, using headers small/large/small:18592251 steps,18432 late +HOME writes, zero header writes, complete cleanup/history/exteriors and both +returned-extent mismatch directions. Reachability finds0 reachable and8 +unreachable header writes. The original review is retained verbatim; a +disclosed portable checker accepts an implementation argument and compares +scientific receipts read-only, ignoring elapsed_seconds alone. No oracle, +CPU or mathematical checks changed. All five registered commands are local +and byte-pinned; the author freeze remains unchanged under implementation/. + +No Gamma6 producer, nine-Gamma root conversion, view packing, cutoff policy, +all-MOVE/caller admission, faster nonleaf rate, assumption discharge or new +kappa. The real source's separate nine-Gamma descriptor is motivation, +not silently identified with Gamma6. Credit the frozen generic core, native +factors, rank-two join, B1 and source/precision lineage. Prepared for @CubeJerry +with substantial OpenAI ChatGPT/Codex assistance; no blind, human or formal- +kernel acceptance. No remote publication performed by this worker. + +## Reproduction, pins and predecessor credit + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. The unchanged author freeze is `0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7`; the exact dependency closure is in `SOURCES.json` and `implementation/SOURCES.json`. + +```sh +python3 -B scripts/research_package.py --package research/borrowed-header-data-only-home +``` + +Expected final marker: `PASS_REGISTERED_RESEARCH_PACKAGE research/borrowed-header-data-only-home outcome=completed`. The five registered commands, their actual stdout, normal/optimized controls and independent receipts are retained. Metadata and source pins pass separately; no hosted CI or selected cold replay is claimed. + +This extends the [fixed-rank positive literal core](https://github.com/CubeJerry/integer-mult-bounds/tree/f2f5130ec84f6a0fc81dbfec9a287909500aa80d/research/literal-fixed-rank-positive-native) and [permanent-HOME dispatcher](https://github.com/CubeJerry/integer-mult-bounds/tree/b4fcc9d64971fdabd0b1d82cfb749d8aac920437/research/compiler-permanent-home-dispatch) by separating a borrowed immutable parameter header from the fixed-size scientific DATA field. It retains #6978's rank-scaled algebra and #7000's selected precision/source framework. Earlier literal primitives and their authors remain credited in the unchanged notices; no source theorem or primitive is claimed anew. diff --git a/research/borrowed-header-data-only-home/PR-TITLE.txt b/research/borrowed-header-data-only-home/PR-TITLE.txt new file mode 100644 index 0000000000..3b36f3ef2f --- /dev/null +++ b/research/borrowed-header-data-only-home/PR-TITLE.txt @@ -0,0 +1 @@ +Separate immutable native headers from DATA-only permanent homes with complete fixed-tape return diff --git a/research/borrowed-header-data-only-home/PUBLICATION-MANIFEST.json b/research/borrowed-header-data-only-home/PUBLICATION-MANIFEST.json new file mode 100644 index 0000000000..c3041b4971 --- /dev/null +++ b/research/borrowed-header-data-only-home/PUBLICATION-MANIFEST.json @@ -0,0 +1,480 @@ +{ + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "FREEZE.json", + "bytes": 15105, + "sha256": "cd72a820418c73557b75c3392547ce0d45786209462aad322479bf0ce6f17186", + "git_blob": "887a7e138ea26f88fec5572bdc81694054860e8e" + }, + { + "path": "PACKAGING-CHECKS.json", + "bytes": 667, + "sha256": "687858f9cda0cf26081ae56164dc4036ff95337a8c7618c041d74336ced76ca8", + "git_blob": "453c85ea06dfa62cee397e5e3b3ed446fa5f77db" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 4824, + "sha256": "d0cc173e9ce04e6e1aa26391edc37fa5f3e443e1cc434bd39410c8f4fd9a5dc7", + "git_blob": "bf635def1ac3e3ff073d715adad6b9bee54e322a" + }, + { + "path": "PR-TITLE.txt", + "bytes": 97, + "sha256": "6262878905310be0e87ed2eb44bfbd0ab5f902ef502deeaad50a99025b15e172", + "git_blob": "3b36f3ef2fe21b166469be89da697ac1f6c4a30e" + }, + { + "path": "README.md", + "bytes": 8073, + "sha256": "4997af62940ba66bd8061af54f55e80d012b4ea4eaeeabb79b5eb707e39595ee", + "git_blob": "e93dd7726d80a1c380f78603312277554afa49e5" + }, + { + "path": "REGISTERED-metadata.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "git_blob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "REGISTERED-metadata.stdout", + "bytes": 69, + "sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647", + "git_blob": "a6c9fb298af70222c4b39bd4618298f11b6e50b4" + }, + { + "path": "REGISTERED-registered.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "git_blob": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "REGISTERED-registered.stdout", + "bytes": 4366, + "sha256": "91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f", + "git_blob": "0c86c1f7941c5ce25f13018ff878a96d1ed5655a" + }, + { + "path": "REVIEW-STATUS.json", + "bytes": 1122, + "sha256": "11aa4289474af475d0b13fa2351d7a279ab138508cbe5cfef1b168b38105a9bc", + "git_blob": "227e983e364c5f0d27225e44b1e17e887c40de00" + }, + { + "path": "SOURCES.json", + "bytes": 5703, + "sha256": "b3d12097e54d9b9fdb6f8479048cda60eb806e8bf56813f2c1ff9f1ade742a44", + "git_blob": "019514e16f4a6f75aa4a99f74ca905e921e5426f" + }, + { + "path": "TASK.json", + "bytes": 7276, + "sha256": "33ec6c87bd099f0b0618b867e946e0741fbeacc3eaa6d95a640668238e46aa37", + "git_blob": "9bba871c1d252983cc322a5e4b3449bae0ae0b68" + }, + { + "path": "VALIDATION.json", + "bytes": 1365, + "sha256": "1f8c42e4dc3d5a22a92985bc33c285052a72e45e5f2acf00fa60a54bd7cc4057", + "git_blob": "7f418bc62e9db21e432f4c61e0acbec6e364d0bc" + }, + { + "path": "VERIFY.json", + "bytes": 2882, + "sha256": "97956d6f762f64c906ece40d1072fc16c7aae6c65b73caf5fa7fc8e20ed89456", + "git_blob": "23294bc27d2052e05ea738157408d74097a71be1" + }, + { + "path": "implementation/CHECKPOINT.json", + "bytes": 1928, + "sha256": "eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500", + "git_blob": "6efae3ad728a92e60f1d4370ca335a4126c09622" + }, + { + "path": "implementation/CHECKSUMS", + "bytes": 4955, + "sha256": "1466b78b44ccd6f965bcd93cfff57bdff9de19bef38cca6de1139a4be08534cf", + "git_blob": "0e379279a7cb8c6b00082287db1a63652fb37a5d" + }, + { + "path": "implementation/FREEZE.json", + "bytes": 8658, + "sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "git_blob": "b909dea89d73b17330c5b78d93bdcaf32e02f74d" + }, + { + "path": "implementation/GRAPH.json", + "bytes": 881, + "sha256": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b", + "git_blob": "82df14a25d3feba291c54b57c4d14bfce24583e6" + }, + { + "path": "implementation/NOTICE.md", + "bytes": 1174, + "sha256": "38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040", + "git_blob": "ef78202ff4bb19789cfe179d8635d73f6cb3a3e8" + }, + { + "path": "implementation/PR-DRAFT.md", + "bytes": 1520, + "sha256": "80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482", + "git_blob": "49de62f9118d4de1c6ed8d465fb3b447bf9ad470" + }, + { + "path": "implementation/PREFLIGHT.md", + "bytes": 2329, + "sha256": "7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef", + "git_blob": "aa7a26b00ab6bcec302dd54698ee4dfc452501d2" + }, + { + "path": "implementation/PROOF.md", + "bytes": 12966, + "sha256": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744", + "git_blob": "a5ebe1752c8dc5064f1fb9fc36ba985265186a76" + }, + { + "path": "implementation/README.md", + "bytes": 1959, + "sha256": "5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3", + "git_blob": "b2dcbd6763b03e9d4a5cb51d228d6082c4e37d8d" + }, + { + "path": "implementation/RESULT.json", + "bytes": 4081, + "sha256": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3", + "git_blob": "79a1e41c68376e4c062a9ebcc57d9b93b406c67c" + }, + { + "path": "implementation/SOURCES.json", + "bytes": 12887, + "sha256": "2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5", + "git_blob": "bc19e261cf47b62b403b610e466fedd2ef257c62" + }, + { + "path": "implementation/adapter.py", + "bytes": 6086, + "sha256": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14", + "git_blob": "060ed0b228f6044fccdfbd1ef3b46a14a2b55e32" + }, + { + "path": "implementation/inputs/core/CHECKPOINT.md", + "bytes": 1877, + "sha256": "ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa", + "git_blob": "6f83792ca059bc5aaefeb5697b3a1359545f7b3e" + }, + { + "path": "implementation/inputs/core/ENVIRONMENT.json", + "bytes": 468, + "sha256": "77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b", + "git_blob": "f541f5cbfe9ea1711055b4b27ead9c8f0482d77e" + }, + { + "path": "implementation/inputs/core/FREEZE.json", + "bytes": 6301, + "sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "git_blob": "b440dc0dec75718f29feb097c5ed2e05d30641fa" + }, + { + "path": "implementation/inputs/core/NOTICE.md", + "bytes": 1756, + "sha256": "4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940", + "git_blob": "1d452e3c19d0a5e9b9acb3868dd59f572a97b68b" + }, + { + "path": "implementation/inputs/core/OVERLAP.md", + "bytes": 2859, + "sha256": "d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c", + "git_blob": "20e55aad29e30249ffa986286f2625f0b1d7c509" + }, + { + "path": "implementation/inputs/core/PR-DESCRIPTION.md", + "bytes": 2398, + "sha256": "794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885", + "git_blob": "614b59012f3ebd1c8bb35148d94bc205d8bf5c81" + }, + { + "path": "implementation/inputs/core/PROOF.md", + "bytes": 12196, + "sha256": "48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb", + "git_blob": "3aa9caacf015a39867a4d372b94ca9f11cabf771" + }, + { + "path": "implementation/inputs/core/README.md", + "bytes": 3479, + "sha256": "7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c", + "git_blob": "98b3a961325252fbd995e6c1c91ee3d35ec0e552" + }, + { + "path": "implementation/inputs/core/RESULT.json", + "bytes": 28741, + "sha256": "95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3", + "git_blob": "e1ee257cc1ae870cfb544b9a2bac2a0d4b197cbd" + }, + { + "path": "implementation/inputs/core/SOURCE-BINDING.json", + "bytes": 1772, + "sha256": "ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232", + "git_blob": "39784ed13310cc1f58407553d42496ae4606a2a5" + }, + { + "path": "implementation/inputs/core/SOURCES.json", + "bytes": 5445, + "sha256": "496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03", + "git_blob": "0cf874beeb63ea8f51d210293d34add335b6c349" + }, + { + "path": "implementation/inputs/core/adapter.py", + "bytes": 4845, + "sha256": "e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534", + "git_blob": "8c1f0bed316deb629bc7fbd685a2e43131c10e0b" + }, + { + "path": "implementation/inputs/core/bind_sources.py", + "bytes": 2850, + "sha256": "c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6", + "git_blob": "c2dee252131a649f2863dc35612639b3abb17c92" + }, + { + "path": "implementation/inputs/core/join.py", + "bytes": 6778, + "sha256": "971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6", + "git_blob": "c1fc922fcc32d271ff463a28fd13fc1a8fb20af6" + }, + { + "path": "implementation/inputs/core/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da" + }, + { + "path": "implementation/inputs/core/reference/pr6978-PROOF.md", + "bytes": 20312, + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d", + "git_blob": "5d619cfc2d3b7bc51e6fcc8e7a46ecd1e313e23d" + }, + { + "path": "implementation/inputs/core/reference/rank2/FREEZE.json", + "bytes": 5633, + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275", + "git_blob": "f8b32e26117bc678bd8003a4567200783e8496af" + }, + { + "path": "implementation/inputs/core/reference/rank2/PROOF.md", + "bytes": 16634, + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352", + "git_blob": "627e54e031945e3cc269b255669c999a0f5995e3" + }, + { + "path": "implementation/inputs/core/reference/rank2/RECIPE.json", + "bytes": 4468, + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702", + "git_blob": "04f5dc8367585afbf272ea2ecbb49cd28ce10919" + }, + { + "path": "implementation/inputs/core/reference/rank2/SOURCES.json", + "bytes": 10337, + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641", + "git_blob": "0ea6091131b526591e5757c56c0a50b50b170b83" + }, + { + "path": "implementation/inputs/core/reference/rank2/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da" + }, + { + "path": "implementation/inputs/core/reference/rank2/rank2.py", + "bytes": 8253, + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a", + "git_blob": "ed3ef68167456e0322314762dab6eb725d9f3a37" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842", + "git_blob": "db83fd95e175c90a2f9e51545b4be4557fbb919e" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099", + "git_blob": "10606f87dcfa0781bcae900d95cb86925961d453" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf", + "git_blob": "71c5f6dae2c799ce5d76c544e98d1ee7c52ef76c" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744", + "git_blob": "bdcc80cbd8b64c601e6d69b7d25ece444b8b1ae2" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50", + "git_blob": "3a3030f23df347c1e45ddf92d2083f89ed16cc67" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33", + "git_blob": "6aad40a6c47ed4415917c86fabbd5227a3819a41" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0", + "git_blob": "7a1f1da9c59d40b1e72905fee5344a8db9ca4353" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "git_blob": "d48978145821fc4a62d534bef2bef9449bda883a" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c" + }, + { + "path": "implementation/inputs/core/verify.py", + "bytes": 9469, + "sha256": "b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471", + "git_blob": "c7f1f5131a7ba6cad64cfdc19cd315f6021a31d9" + }, + { + "path": "implementation/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da" + }, + { + "path": "implementation/verify.py", + "bytes": 7746, + "sha256": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4", + "git_blob": "b51d552af89d0105c96db5bb46d1faeb721163f2" + }, + { + "path": "review/interface/PORTABILITY.json", + "bytes": 745, + "sha256": "90f6b2fd89c1ae65e8e5d82b77f8901025bce9599bde6b8d93e99fa3a024f911", + "git_blob": "8c8aab6c9a2b011a95a1e2e47457bc03289eb919" + }, + { + "path": "review/interface/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5", + "git_blob": "1e9e07cdfe4dfdf631372da927c54209dd315d64" + }, + { + "path": "review/interface/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26", + "git_blob": "52c6274e09a640d30502564d3132b1f523e7358f" + }, + { + "path": "review/interface/check_review.py", + "bytes": 9363, + "sha256": "d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb", + "git_blob": "222cd7a81865238470fcca721807f8ff15fdd5cd" + }, + { + "path": "review/interface/original/CHECKPOINT.md", + "bytes": 1125, + "sha256": "76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495", + "git_blob": "a7e11ed70a442f069dc532b641ff0c4a3c69e87c" + }, + { + "path": "review/interface/original/MANIFEST.json", + "bytes": 826, + "sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f", + "git_blob": "3147be66ec6d809d06c9df5cf4befb7d60854e2a" + }, + { + "path": "review/interface/original/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5", + "git_blob": "1e9e07cdfe4dfdf631372da927c54209dd315d64" + }, + { + "path": "review/interface/original/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26", + "git_blob": "52c6274e09a640d30502564d3132b1f523e7358f" + }, + { + "path": "review/interface/original/check_review.py", + "bytes": 9157, + "sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590", + "git_blob": "bc0a231be387346d088a6e4e69349f130cceaaea" + }, + { + "path": "review/packaging/BASE-FREEZE.json", + "bytes": 14556, + "sha256": "bd7c82f6b63d116cab55761933f2941613e28f98b652945dd487152db53c261b", + "git_blob": "6e9421431346a0daaec91d6f9672d31ff42ba83a" + }, + { + "path": "review/packaging/INTEGRATION-NOTE.md", + "bytes": 419, + "sha256": "ba087d28b7b07f46f6a5ebcccea39c3f126eff56dbf9be35deffad1aa8f81625", + "git_blob": "c6459062509f40982ded302bae6cf8db4b239098" + }, + { + "path": "review/root/RESULT.json", + "bytes": 1360, + "sha256": "3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502", + "git_blob": "e9fb2c6bbb2823e216eaccef76e328697184870e" + }, + { + "path": "review/root/ROOT-REVIEW.md", + "bytes": 4608, + "sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6", + "git_blob": "5b3b385538a644a3a8f3307f90a776d029c9ecd5" + }, + { + "path": "review/root/check_borrowed_root.py", + "bytes": 7464, + "sha256": "98e8991f6e85692dc523dab5479e2094072377f3cfbefe443959f3ce68013a2e", + "git_blob": "018a63a2c940744be87419a9cd58e5fbfbb750a5" + } + ], + "scope": "Supplied immutable Gamma6 HEADER plus already-packed DATA-only HOME; no root producer/view/cutoff-policy/caller/nonleaf or kappa claim." +} diff --git a/research/borrowed-header-data-only-home/README.md b/research/borrowed-header-data-only-home/README.md new file mode 100644 index 0000000000..e93dd7726d --- /dev/null +++ b/research/borrowed-header-data-only-home/README.md @@ -0,0 +1,140 @@ +# Borrowed native HEADER with DATA-only permanent homes + +Inline Gamma6/HOME adapters put encoded metadata inside each scientific +field, tying its extent to E+V. This package supplies a literal fixed-rho +wrapper with a separate immutable borrowed Gamma6 HEADER and a HOME body +containing exactly V scientific DATA bits. Changing header lengths need +not agree, and no padding is added to native DATA. + +The original author snapshot is frozen unchanged under implementation/. +Author normal/optimized replay, separate root execution and A's independent +proof/interface audit pass. Final registered portable replay and the outer +freeze are recorded separately; original implementation bytes stay unchanged. + +## Supplied boundary and complete costs + +Fix native positive rank rho in1..9 at construction. Supply a separate +Gamma6 HEADER for `(f,r,P,S,w,cutoff)` and already-packed complete DATA on +`[P] x [2^f]^9 x [S]`, with r Gaussian coefficients per address, real then +imaginary signed w-bit MSB-first components on one supplied unchanged grid. +`V=2PSr2^(9f)w`; E counts every header bit. The actual core checks +`rho*f<=cutoff`, and every executed C-prefix result must be integral and +fit the width. Endpoint fit alone is insufficient. + +F_HOME=V independently of E. The unchanged positive native core retains +all nine slots, spectators, coefficients and exact phase. The wrapper returns +only DATA to the same HOME, preserves the borrowed header/tail and restores +every successful head, private body, guard and native guide. A single-header +graph uses **34 fixed tapes**; the two-header fixture uses **35**, because +both distinct public headers exist at initial entry. + +HEADER's native origin is B-relative1. Native DATA/private origins are2, +placing private guards at blank1 and keeping permanent^0 intact. The graph +starts at the already-reserved B1 execution boundary. Its original unreachable +reservation prefix remains in the table and must not execute on HEADER3. +The constructor checks every reachable state for header writes. No typed +reservation is supplied. + +Wrapper time is at most256(V+1), with64(V+1) additional visited backing. +Including the unchanged core and any separately charged fixed setup: + +```text +T <= Setup_rho + 256(V+1) + 2^24(fV+E+1) +K_final <= K_entry + 2112(V+E+1) +``` + +K_entry retains all previous larger backing, borrowed headers and opaque +exteriors. E remains charged even though it is outside HOME. B1 full-bank +delivery, operand retirement and reservation have their separate invoice. +The direct fV rate does not establish a faster nonleaf service. Read +[implementation/PROOF.md](implementation/PROOF.md) for exact entry and costs. + +## Author execution and separate root evidence + +Two complete f1/rho1 author calls reuse the same6144-bit HOME and native +banks with E10/E268 headers, cutoff bit lengths1/130, both supplied at entry. +No host header replacement/producer is counted as physical work. C squared +gives the exact selected-axis swap in2452104 transitions, with12288 HOME +writes and zero borrowed HEADER writes. Checkpoints precede native return +and scatter. Cutoff, short-DATA and late nonintegrality examples leave HOME +unchanged. Emitted faults test returned extent, wrong-home scatter and skipped +private return. Guard-offset detection is a test monitor, not runtime +protection. Rejection cleanup/retry and universal malformed validation remain +outside the contract. + +The root separately executes a fresh rho2 packet with f=r=P=1,S=2,w=7, +V14336,E270 and a130-bit cutoff. Its sparse CPU and closed two-axis Gaussian +Hamming kernel use neither the author's CPU nor numerical oracle/fixture. +It checks all25242 native instructions and every reachable state. The full +34-tape run takes13698674 transitions, writes exactly14336 HOME bits after +primitive return, zero earlier HOME bits and zero HEADER bits. Header reads +are exactly cells1..270, so the immediate opaque suffix is not read. All +heads/private bodies/guards/exteriors return and the parked HOME is unchanged. +See [review/root/ROOT-REVIEW.md](review/root/ROOT-REVIEW.md) and its receipt. + +A independently compares1373214 retained instructions for all nine ranks +and both header ports. Its separate signed-origin sparse CPU executes three +rho2 calls on the same6144-bit HOME with E12/12308 and header sequence3,34,3. +The larger header exceeds DATA. It takes18592251 steps, writes HOME18432 +times and headers zero times, restores all heads/private/exteriors/history, +and rejects both short/long returned extents before scatter. Its separate +reachability check finds0 reachable/8 unreachable header writes. See +review/interface/REVIEW.md. The original review is retained verbatim under +review/interface/original/. PORTABILITY.json discloses only two changes: +accept an implementation argument and replace unconditional receipt writes +with read-only scientific comparison excluding elapsed_seconds alone. No +oracle, CPU or mathematical checks changed. These executions corroborate the +all-input proof; no blind, human or formal-kernel review is claimed. +The roles share and inspect the proposed construction. + +## Reproduction + +Python3.12 and the standard library, from the repository root: + +```sh +python3 -I -B -W error research/borrowed-header-data-only-home/implementation/verify.py +python3 -I -O -B -W error research/borrowed-header-data-only-home/implementation/verify.py +python3 -I -B -W error research/borrowed-header-data-only-home/review/root/check_borrowed_root.py research/borrowed-header-data-only-home/implementation +python3 -I -B -W error research/borrowed-header-data-only-home/review/interface/check_review.py research/borrowed-header-data-only-home/implementation +python3 -I -O -B -W error research/borrowed-header-data-only-home/review/interface/check_review.py research/borrowed-header-data-only-home/implementation +python3 -B scripts/research_package.py --package research/borrowed-header-data-only-home --check-only +python3 -B scripts/research_package.py --package research/borrowed-header-data-only-home +``` + +Expected author marker is PASS_BORROWED_HEADER_DATA_HOME; root receipt status +is PASS_ROOT_BORROWED_HEADER_RANK2; interface marker is +PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW. Defaults are read-only and compare the +author's frozen receipt; --write explicitly changes that receipt. Runtime +inputs are local and authenticated before imports; fresh required-absent +cache prefixes prevent stale bytecode substitution. VERIFY.json registers +five commands: author normal/optimized, root sparse CPU and interface +normal/optimized, with explicit implementation arguments for both reviews. + +Original author FREEZE hash: +`0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7`. +The native core remains frozen by +`5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef`. +Original implementation/proof/status/notice/draft bytes are retained exactly. + +## Open next questions + +TASK.json records concrete remaining interfaces: produce one admitted Gamma6 +header from the actual separate nine-Gamma root descriptor and ROW grant; +implement the named source view and inverse packing with its full cost; and +compose complete monomial/MOVE/caller services around this supplied positive +primitive. Each needs real occurrence, owner, grid/prefix and cutoff-policy +binding. Equal DATA volume does not itself implement a coordinate permutation. + +## Kappa and credit + +No new kappa. The selected value363005817/100000000000 remains under all +five retained assumptions. No source producer, root conversion, view packing, +cutoff derivation/policy, all-MOVE or actual caller admission, faster nonleaf +tariff or multiplier is supplied here. + +Prepared for @CubeJerry with substantial OpenAI ChatGPT/Codex assistance. +Worker B supplied the wrapper/proof; root separately checked physical +execution/arithmetic and A supplied the independent interface proof/checker. Credit the unchanged +generic positive core, rank-two/literal phase/CNOT/C lineage, B1 and the +source/root-format work. Retain implementation/NOTICE.md and all upstream +notices. Apache-2.0. diff --git a/research/borrowed-header-data-only-home/REGISTERED-metadata.stderr b/research/borrowed-header-data-only-home/REGISTERED-metadata.stderr new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/borrowed-header-data-only-home/REGISTERED-metadata.stdout b/research/borrowed-header-data-only-home/REGISTERED-metadata.stdout new file mode 100644 index 0000000000..a6c9fb298a --- /dev/null +++ b/research/borrowed-header-data-only-home/REGISTERED-metadata.stdout @@ -0,0 +1 @@ +PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) diff --git a/research/borrowed-header-data-only-home/REGISTERED-registered.stderr b/research/borrowed-header-data-only-home/REGISTERED-registered.stderr new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/borrowed-header-data-only-home/REGISTERED-registered.stdout b/research/borrowed-header-data-only-home/REGISTERED-registered.stdout new file mode 100644 index 0000000000..0c86c1f794 --- /dev/null +++ b/research/borrowed-header-data-only-home/REGISTERED-registered.stdout @@ -0,0 +1,58 @@ +CHECK author replay: two complete same-HOME rank1 calls with immutable E10/E268 headers, exact C squared swap, full heads/private/exterior retirement and cutoff/short-DATA/late-scatter controls. No producer or malformed-input validator claimed. +PASS_BORROWED_HEADER_DATA_HOME: immutable headers, complete DATA-only returns and controls. +CHECK Optimized author replay: two complete same-HOME rank1 calls with immutable E10/E268 headers, exact C squared swap, full heads/private/exterior retirement and cutoff/short-DATA/late-scatter controls. No producer or malformed-input validator claimed. +PASS_BORROWED_HEADER_DATA_HOME: immutable headers, complete DATA-only returns and controls. +CHECK Separate sparse CPU and closed rank-two Gaussian Hamming kernel on a fresh complete f1 S2 w7 DATA-only packet with a130-bit cutoff and immediate opaque HEADER suffix; exact core injection, reachable read-only HEADER, late same-owner scatter, all34 heads/private/exterior returns and full time/history bounds. +{ + "E": 270, + "HOME_body_length": 14336, + "V": 14336, + "core_instructions": 25242, + "core_sha256": "c4d8abeb423b1f094d813916331d1fd89a905536a24b9719d450296f1f1fcabb", + "cutoff_bit_length": 130, + "input_sha256": "b3641704bfdf68f58aa5de106bb37bee9ce221db1e1967c625a15b7c6169e505", + "oracle": "Closed two-axis Hamming-distance Gaussian kernel; no author CPU/fixture/oracle imported", + "output_sha256": "e6dbee1eb349a832d3ef2821d4c66997eb65e61f5075d75d697b9143d7659de0", + "reachable_states": 25383, + "receipt": { + "HEADER_writes": 0, + "HOME_writes": 14336, + "checkpoints": { + "POSITIVE.69": { + "HOME_writes": 0, + "steps": 114767 + }, + "jump.5": { + "HOME_writes": 0, + "steps": 13626984 + }, + "jump.68": { + "HOME_writes": 0, + "steps": 13583910 + } + }, + "early_HOME_writes": 0, + "entry_head_history": 98987, + "final_head_history": 278941, + "header_read_first": 1, + "header_read_last": 270, + "steps": 13698674 + }, + "scope": "One fresh complete rank2 f1 DATA-only call with spectators and an immediate opaque HEADER suffix; no actual header/view producer or caller admission.", + "shape": [ + 1, + 1, + 1, + 2, + 7, + 680564733841876926926749214863536422913 + ], + "states": 25393, + "status": "PASS_ROOT_BORROWED_HEADER_RANK2", + "tapes": 34 +} +CHECK independent source/interface review: direct-PC injection of1373214 instructions for allrho1..9/header3,34; separate sparse signed-origin CPU executes3 rank2 calls with E12/12308>V6144, same-owner small/large/small reuse, all cleanup/history/exteriors and both returned-extent mismatch directions. Read-only scientific receipt comparison; only elapsed_seconds excluded. +{"embedded_instructions_checked": 1373214, "marker": "PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW", "packet": {"HOME_writes": 18432, "V": 6144, "final_output_sha256": "a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25", "header_lengths": [12, 12308], "header_sequence": [3, 34, 3], "header_writes": [0, 0], "rank": 2, "reachable_header_writes": 0, "returned_extent_faults": ["short", "long"], "signed_origins": true, "steps": 18592251, "unreachable_header_writes": 8}, "subject_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7"} +CHECK Optimized independent source/interface review: direct-PC injection of1373214 instructions for allrho1..9/header3,34; separate sparse signed-origin CPU executes3 rank2 calls with E12/12308>V6144, same-owner small/large/small reuse, all cleanup/history/exteriors and both returned-extent mismatch directions. Read-only scientific receipt comparison; only elapsed_seconds excluded. +{"embedded_instructions_checked": 1373214, "marker": "PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW", "packet": {"HOME_writes": 18432, "V": 6144, "final_output_sha256": "a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25", "header_lengths": [12, 12308], "header_sequence": [3, 34, 3], "header_writes": [0, 0], "rank": 2, "reachable_header_writes": 0, "returned_extent_faults": ["short", "long"], "signed_origins": true, "steps": 18592251, "unreachable_header_writes": 8}, "subject_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7"} +PASS_REGISTERED_RESEARCH_PACKAGE research/borrowed-header-data-only-home outcome=completed diff --git a/research/borrowed-header-data-only-home/REVIEW-STATUS.json b/research/borrowed-header-data-only-home/REVIEW-STATUS.json new file mode 100644 index 0000000000..227e983e36 --- /dev/null +++ b/research/borrowed-header-data-only-home/REVIEW-STATUS.json @@ -0,0 +1,26 @@ +{ + "status": "ready_for_root_publication", + "author_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "root": { + "status": "passed", + "source_path": "root-work/borrowed-header-review/check_borrowed_root.py", + "expected_publication_paths": [ + "review/root/check_borrowed_root.py", + "review/root/RESULT.json", + "review/root/ROOT-REVIEW.md" + ], + "review_sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6", + "receipt_sha256": "3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502" + }, + "interface": { + "status": "passed", + "reviewer_role": "A/native_move", + "expected_publication_paths": [ + "review/interface/REVIEW.md", + "review/interface/RESULT.json" + ], + "review_sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26", + "original_manifest_sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f" + }, + "publication_freeze": "All five registered commands and metadata/source pins passed; outer snapshot frozen. No validation-global mutation." +} diff --git a/research/borrowed-header-data-only-home/SOURCES.json b/research/borrowed-header-data-only-home/SOURCES.json new file mode 100644 index 0000000000..019514e16f --- /dev/null +++ b/research/borrowed-header-data-only-home/SOURCES.json @@ -0,0 +1,154 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + } + ], + "external_primary_provenance": "implementation/SOURCES.json and its frozen core manifest pin the complete unchanged native/B1 closure. Local retained bytes are authenticated before imports. No remote runtime inputs.", + "author_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "generic_core_freeze_sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "review_status": "Both separate reviews pass; all five registered portable commands and official metadata/source-pin checks pass.", + "local_scientific_artifacts": [ + { + "path": "implementation/FREEZE.json", + "bytes": 8658, + "sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7" + }, + { + "path": "implementation/PROOF.md", + "bytes": 12966, + "sha256": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744" + }, + { + "path": "implementation/adapter.py", + "bytes": 6086, + "sha256": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14" + }, + { + "path": "implementation/verify.py", + "bytes": 7746, + "sha256": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4" + }, + { + "path": "implementation/RESULT.json", + "bytes": 4081, + "sha256": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3" + }, + { + "path": "implementation/GRAPH.json", + "bytes": 881, + "sha256": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b" + }, + { + "path": "implementation/SOURCES.json", + "bytes": 12887, + "sha256": "2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5" + }, + { + "path": "review/root/ROOT-REVIEW.md", + "bytes": 4608, + "sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6" + }, + { + "path": "review/root/RESULT.json", + "bytes": 1360, + "sha256": "3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502" + }, + { + "path": "review/root/check_borrowed_root.py", + "bytes": 7464, + "sha256": "98e8991f6e85692dc523dab5479e2094072377f3cfbefe443959f3ce68013a2e" + }, + { + "path": "review/interface/PORTABILITY.json", + "bytes": 745, + "sha256": "90f6b2fd89c1ae65e8e5d82b77f8901025bce9599bde6b8d93e99fa3a024f911" + }, + { + "path": "review/interface/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/check_review.py", + "bytes": 9363, + "sha256": "d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb" + }, + { + "path": "review/interface/original/CHECKPOINT.md", + "bytes": 1125, + "sha256": "76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495" + }, + { + "path": "review/interface/original/MANIFEST.json", + "bytes": 826, + "sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f" + }, + { + "path": "review/interface/original/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/original/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/original/check_review.py", + "bytes": 9157, + "sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590" + }, + { + "path": "VALIDATION.json", + "bytes": 1365, + "sha256": "1f8c42e4dc3d5a22a92985bc33c285052a72e45e5f2acf00fa60a54bd7cc4057" + }, + { + "path": "REGISTERED-metadata.stdout", + "bytes": 69, + "sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647" + }, + { + "path": "REGISTERED-registered.stdout", + "bytes": 4366, + "sha256": "91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f" + } + ], + "root_review_source": { + "author_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "independent_checker": "review/root/check_borrowed_root.py", + "independent_receipt": "review/root/RESULT.json", + "proof": "review/root/ROOT-REVIEW.md" + }, + "interface_review_source": { + "review": "review/interface/REVIEW.md", + "receipt": "review/interface/RESULT.json", + "checker": "review/interface/check_review.py", + "original_checker": "review/interface/original/check_review.py", + "original_manifest": "review/interface/original/MANIFEST.json", + "portability": "review/interface/PORTABILITY.json" + } +} diff --git a/research/borrowed-header-data-only-home/TASK.json b/research/borrowed-header-data-only-home/TASK.json new file mode 100644 index 0000000000..9bba871c1d --- /dev/null +++ b/research/borrowed-header-data-only-home/TASK.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "task_id": "uniform-transfer-audit", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "scope_change_reason": "Refine the inherited-assumption card to one physical borrowed-header/DATA-only HOME boundary. The actual root producer, packing, cutoff policy and selected caller remain supplied.", + "actual_scope": "For each fixed native rank rho in1..9, embed the unchanged frozen positive core with a distinct immutable supplied Gamma6 HEADER and already-packed DATA-only HOME of extent V; return exactly DATA to the same owner and restore all successful private/head/guard state with complete local time and retained-history bounds.", + "bottleneck_link": "Removes the inline-header E+V extent requirement at a literal supplied primitive boundary. It composes B1 bank delivery with the separate native HEADER/DATA core without assuming equal Gamma lengths or padding scientific DATA.", + "stop_rule": "Stop after the frozen wrapper, unequal-E same-owner execution, rejection and late-scatter controls, and separate root/interface review. Do not implement a header producer or view permutation, infer all-MOVE/caller admission or claim a faster nonleaf rate.", + "evidence": "implementation/PROOF.md; implementation/FREEZE.json; implementation/GRAPH.json; implementation/RESULT.json; review/root/ROOT-REVIEW.md and RESULT.json; review/interface/REVIEW.md, RESULT.json, original/MANIFEST.json and PORTABILITY.json; VERIFY.json registered commands.", + "author": "@CubeJerry", + "ai_assistance": "Prepared for @CubeJerry with substantial OpenAI ChatGPT/Codex assistance. Worker B implemented the wrapper and proof; root separately executes a fresh numerical packet with a sparse CPU/oracle; A separately audits the supplied interface and proof. Proposed construction and sources are shared, so no blind, human or formal-kernel review is claimed.", + "outcome": "completed", + "open_questions": [ + { + "question": "Can the actual nine-Gamma selected root descriptor produce this valid borrowed Gamma6 HEADER and its numerical-prefix contract?", + "why_it_matters": "This wrapper accepts an already supplied header/view and proves no source producer or cutoff policy.", + "first_step": "Bind one source-qualified occurrence and actual ROW grant to its f,r,P,S,w,cutoff header and common grid.", + "blocked_by": "Runtime root/ROW/occurrence descriptor production and numerical/cutoff admission remain separate." + }, + { + "question": "Can the source-strided selected bits be packed and returned around this DATA-only interface with their full cost and retained spectators?", + "why_it_matters": "Equal volume alone does not implement the coordinate permutation required by the native packed core.", + "first_step": "Implement one actual source view and inverse return while retaining every compact, unselected and completed root coordinate.", + "blocked_by": "The wrapper starts after packing; the simple fV schedule does not supply a faster nonleaf tariff." + }, + { + "question": "Can complete monomial/MOVE and caller services use DATA-only HOME bodies while preserving the full bank and numerical chronology?", + "why_it_matters": "A positive central primitive is narrower than source-wide MOVE/scalar/caller execution.", + "first_step": "Compose one authenticated complete recipe with its header, phases, linear and affine factors, delivery and dirty lifetime invoice.", + "blocked_by": "All-MOVE and selected caller admission, source producers and nonleaf mechanisms are outside this package." + } + ] +} diff --git a/research/borrowed-header-data-only-home/VALIDATION.json b/research/borrowed-header-data-only-home/VALIDATION.json new file mode 100644 index 0000000000..7f418bc62e --- /dev/null +++ b/research/borrowed-header-data-only-home/VALIDATION.json @@ -0,0 +1,33 @@ +{ + "schema": "publication-validation/1", + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "utc": "2026-11-13 14:49 UTC", + "environment": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]", + "commands_executed": 5, + "records": [ + { + "label": "metadata", + "exit": 0, + "seconds": 0.476, + "stdout_sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647", + "stderr": "" + }, + { + "label": "registered", + "exit": 0, + "seconds": 71.686, + "stdout_sha256": "91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f", + "stderr": "" + } + ], + "author_normal_optimized": true, + "root_sparse_rank2": true, + "interface_normal_optimized": true, + "author_freeze_unchanged": true, + "portable_reviews_read_only": true, + "metadata_and_source_pins": "PASS_PACKAGE_METADATA_AND_PINS", + "registered_replay": "PASS_REGISTERED_RESEARCH_PACKAGE research/borrowed-header-data-only-home outcome=completed", + "method": "Unchanged official runner in a temporary copied publication overlay; canonical stored Git provenance read with GIT_NO_LAZY_FETCH=1. No shared source/worktree or validation-global changes.", + "elapsed_seconds": 72.191, + "scope": "Supplied-entry wrapper and disclosed independent checks; no producer/view/cutoff-policy/caller/nonleaf or kappa claim." +} diff --git a/research/borrowed-header-data-only-home/VERIFY.json b/research/borrowed-header-data-only-home/VERIFY.json new file mode 100644 index 0000000000..23294bc27d --- /dev/null +++ b/research/borrowed-header-data-only-home/VERIFY.json @@ -0,0 +1,74 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/implementation/verify.py" + ], + "timeout_seconds": 180, + "checks": "author replay: two complete same-HOME rank1 calls with immutable E10/E268 headers, exact C squared swap, full heads/private/exterior retirement and cutoff/short-DATA/late-scatter controls. No producer or malformed-input validator claimed." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "-W", + "error", + "{package}/implementation/verify.py" + ], + "timeout_seconds": 180, + "checks": "Optimized author replay: two complete same-HOME rank1 calls with immutable E10/E268 headers, exact C squared swap, full heads/private/exterior retirement and cutoff/short-DATA/late-scatter controls. No producer or malformed-input validator claimed." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/review/root/check_borrowed_root.py", + "{package}/implementation" + ], + "timeout_seconds": 240, + "checks": "Separate sparse CPU and closed rank-two Gaussian Hamming kernel on a fresh complete f1 S2 w7 DATA-only packet with a130-bit cutoff and immediate opaque HEADER suffix; exact core injection, reachable read-only HEADER, late same-owner scatter, all34 heads/private/exterior returns and full time/history bounds." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/review/interface/check_review.py", + "{package}/implementation" + ], + "timeout_seconds": 240, + "checks": "independent source/interface review: direct-PC injection of1373214 instructions for allrho1..9/header3,34; separate sparse signed-origin CPU executes3 rank2 calls with E12/12308>V6144, same-owner small/large/small reuse, all cleanup/history/exteriors and both returned-extent mismatch directions. Read-only scientific receipt comparison; only elapsed_seconds excluded." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "-W", + "error", + "{package}/review/interface/check_review.py", + "{package}/implementation" + ], + "timeout_seconds": 240, + "checks": "Optimized independent source/interface review: direct-PC injection of1373214 instructions for allrho1..9/header3,34; separate sparse signed-origin CPU executes3 rank2 calls with E12/12308>V6144, same-owner small/large/small reuse, all cleanup/history/exteriors and both returned-extent mismatch directions. Read-only scientific receipt comparison; only elapsed_seconds excluded." + } + ] +} diff --git a/research/borrowed-header-data-only-home/implementation/CHECKPOINT.json b/research/borrowed-header-data-only-home/implementation/CHECKPOINT.json new file mode 100644 index 0000000000..6efae3ad72 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/CHECKPOINT.json @@ -0,0 +1,42 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "Fixed-rho borrowed immutable Gamma6 HEADER and already-packed DATA-only HOME; exact same-owner return/cleanup, F_HOME=V independent E.", + "core_FREEZE_sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "entry": "Already-reserved B1 execution_start; original unreachable reservation prefix is not executed on HEADER3.", + "excluded": [ + "root/nine-Gamma conversion or header producer", + "view packing", + "cutoff derivation/policy", + "all-MOVE or actual caller", + "faster nonleaf rate", + "selected assumption discharge or kappa" + ], + "full_DATA_bits": 6144, + "hashes": { + "GRAPH.json": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b", + "PROOF.md": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744", + "RESULT.json": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3", + "adapter.py": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14", + "verify.py": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4" + }, + "header_lengths": [ + 10, + 268 + ], + "known_defects": [], + "native_DATA_private_origins": 2, + "native_HEADER_origin": 1, + "normal_exit": 0, + "optimized_exit": 0, + "previous_packages_unchanged": true, + "primitive_history": "K_entry+2112(V+E+1); B1 and complete entry/exterior history separately retained", + "remote_mutations": false, + "reuse": "Both immutable headers supplied at initial entry; same HOME and native private owners/origins reused. No host replacement counted as implementation.", + "single_header_tapes": 34, + "status": "FROZEN_AUTHOR_SNAPSHOT_FOR_REVIEW", + "two_call_steps": 2452104, + "two_header_fixture_tapes": 35, + "utc": "2026-11-13 14:23 UTC", + "validation_receipt": "RESULT.json", + "wrapper_time": "<=256(V+1) plus core2^24(fV+E+1) and fixed Setup_rho" +} diff --git a/research/borrowed-header-data-only-home/implementation/CHECKSUMS b/research/borrowed-header-data-only-home/implementation/CHECKSUMS new file mode 100644 index 0000000000..0e379279a7 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/CHECKSUMS @@ -0,0 +1,50 @@ +eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500 CHECKPOINT.json +0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7 FREEZE.json +2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b GRAPH.json +38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040 NOTICE.md +80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482 PR-DRAFT.md +7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef PREFLIGHT.md +667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744 PROOF.md +5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3 README.md +143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3 RESULT.json +2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5 SOURCES.json +182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14 adapter.py +ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa inputs/core/CHECKPOINT.md +77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b inputs/core/ENVIRONMENT.json +5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef inputs/core/FREEZE.json +4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940 inputs/core/NOTICE.md +d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c inputs/core/OVERLAP.md +794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885 inputs/core/PR-DESCRIPTION.md +48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb inputs/core/PROOF.md +7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c inputs/core/README.md +95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3 inputs/core/RESULT.json +ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232 inputs/core/SOURCE-BINDING.json +496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03 inputs/core/SOURCES.json +e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534 inputs/core/adapter.py +c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6 inputs/core/bind_sources.py +971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6 inputs/core/join.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee inputs/core/machine.py +2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d inputs/core/reference/pr6978-PROOF.md +072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275 inputs/core/reference/rank2/FREEZE.json +93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352 inputs/core/reference/rank2/PROOF.md +b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702 inputs/core/reference/rank2/RECIPE.json +659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641 inputs/core/reference/rank2/SOURCES.json +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee inputs/core/reference/rank2/machine.py +3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a inputs/core/reference/rank2/rank2.py +b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842 inputs/core/reference/rank2/reference/home/NOTICE.md +04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099 inputs/core/reference/rank2/reference/home/parent_adapter.py +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 inputs/core/reference/rank2/reference/home/tape_graph.py +773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf inputs/core/reference/rank2/reference/leaf/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py +bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744 inputs/core/reference/rank2/reference/leaf/leaf.py +2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50 inputs/core/reference/rank2/reference/linear/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py +d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33 inputs/core/reference/rank2/reference/linear/linear.py +5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0 inputs/core/reference/rank2/reference/phase/NOTICE +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py +2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7 inputs/core/reference/rank2/reference/phase/phase.py +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 inputs/core/reference/rank2/reference/source/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 inputs/core/reference/rank2/reference/source/native_verify.py +b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471 inputs/core/verify.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee machine.py +54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4 verify.py diff --git a/research/borrowed-header-data-only-home/implementation/FREEZE.json b/research/borrowed-header-data-only-home/implementation/FREEZE.json new file mode 100644 index 0000000000..b909dea89d --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/FREEZE.json @@ -0,0 +1,259 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "excluded_paths": [ + "FREEZE.json (self)", + "CHECKSUMS (includes FREEZE)" + ], + "files": [ + { + "bytes": 1928, + "path": "CHECKPOINT.json", + "sha256": "eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500" + }, + { + "bytes": 881, + "path": "GRAPH.json", + "sha256": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b" + }, + { + "bytes": 1174, + "path": "NOTICE.md", + "sha256": "38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040" + }, + { + "bytes": 1520, + "path": "PR-DRAFT.md", + "sha256": "80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482" + }, + { + "bytes": 2329, + "path": "PREFLIGHT.md", + "sha256": "7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef" + }, + { + "bytes": 12966, + "path": "PROOF.md", + "sha256": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744" + }, + { + "bytes": 1959, + "path": "README.md", + "sha256": "5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3" + }, + { + "bytes": 4081, + "path": "RESULT.json", + "sha256": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3" + }, + { + "bytes": 12887, + "path": "SOURCES.json", + "sha256": "2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5" + }, + { + "bytes": 6086, + "path": "adapter.py", + "sha256": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14" + }, + { + "bytes": 1877, + "path": "inputs/core/CHECKPOINT.md", + "sha256": "ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa" + }, + { + "bytes": 468, + "path": "inputs/core/ENVIRONMENT.json", + "sha256": "77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b" + }, + { + "bytes": 6301, + "path": "inputs/core/FREEZE.json", + "sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef" + }, + { + "bytes": 1756, + "path": "inputs/core/NOTICE.md", + "sha256": "4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940" + }, + { + "bytes": 2859, + "path": "inputs/core/OVERLAP.md", + "sha256": "d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c" + }, + { + "bytes": 2398, + "path": "inputs/core/PR-DESCRIPTION.md", + "sha256": "794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885" + }, + { + "bytes": 12196, + "path": "inputs/core/PROOF.md", + "sha256": "48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb" + }, + { + "bytes": 3479, + "path": "inputs/core/README.md", + "sha256": "7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c" + }, + { + "bytes": 28741, + "path": "inputs/core/RESULT.json", + "sha256": "95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3" + }, + { + "bytes": 1772, + "path": "inputs/core/SOURCE-BINDING.json", + "sha256": "ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232" + }, + { + "bytes": 5445, + "path": "inputs/core/SOURCES.json", + "sha256": "496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03" + }, + { + "bytes": 4845, + "path": "inputs/core/adapter.py", + "sha256": "e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534" + }, + { + "bytes": 2850, + "path": "inputs/core/bind_sources.py", + "sha256": "c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6" + }, + { + "bytes": 6778, + "path": "inputs/core/join.py", + "sha256": "971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6" + }, + { + "bytes": 6041, + "path": "inputs/core/machine.py", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "bytes": 20312, + "path": "inputs/core/reference/pr6978-PROOF.md", + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d" + }, + { + "bytes": 5633, + "path": "inputs/core/reference/rank2/FREEZE.json", + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275" + }, + { + "bytes": 16634, + "path": "inputs/core/reference/rank2/PROOF.md", + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352" + }, + { + "bytes": 4468, + "path": "inputs/core/reference/rank2/RECIPE.json", + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + }, + { + "bytes": 10337, + "path": "inputs/core/reference/rank2/SOURCES.json", + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641" + }, + { + "bytes": 6041, + "path": "inputs/core/reference/rank2/machine.py", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "bytes": 8253, + "path": "inputs/core/reference/rank2/rank2.py", + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a" + }, + { + "bytes": 2093, + "path": "inputs/core/reference/rank2/reference/home/NOTICE.md", + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "bytes": 5353, + "path": "inputs/core/reference/rank2/reference/home/parent_adapter.py", + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "bytes": 12069, + "path": "inputs/core/reference/rank2/reference/home/tape_graph.py", + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "bytes": 1900, + "path": "inputs/core/reference/rank2/reference/leaf/NOTICE.md", + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "bytes": 5938, + "path": "inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 17526, + "path": "inputs/core/reference/rank2/reference/leaf/leaf.py", + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "bytes": 2180, + "path": "inputs/core/reference/rank2/reference/linear/NOTICE.md", + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "bytes": 5938, + "path": "inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 13102, + "path": "inputs/core/reference/rank2/reference/linear/linear.py", + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "bytes": 808, + "path": "inputs/core/reference/rank2/reference/phase/NOTICE", + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "bytes": 5938, + "path": "inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 11734, + "path": "inputs/core/reference/rank2/reference/phase/phase.py", + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "bytes": 6824, + "path": "inputs/core/reference/rank2/reference/source/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "bytes": 12323, + "path": "inputs/core/reference/rank2/reference/source/native_verify.py", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "bytes": 9469, + "path": "inputs/core/verify.py", + "sha256": "b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471" + }, + { + "bytes": 6041, + "path": "machine.py", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "bytes": 7746, + "path": "verify.py", + "sha256": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4" + } + ], + "known_defects": [], + "normal_and_optimized_replays": "PASS", + "scope": "Fixed-rho borrowed immutable Gamma6 HEADER and already-packed DATA-only HOME; exact same-owner return/cleanup, F_HOME=V independent E.", + "status": "FROZEN", + "utc": "2026-11-13 14:23 UTC" +} diff --git a/research/borrowed-header-data-only-home/implementation/GRAPH.json b/research/borrowed-header-data-only-home/implementation/GRAPH.json new file mode 100644 index 0000000000..82df14a25d --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/GRAPH.json @@ -0,0 +1,29 @@ +{ + "core_rank1_locations": 8225, + "core_rank1_repr_sha256": "538e1dc21b73c4e123d838bb0c01570db9811f5bc6963ff47a122d359e631da9", + "graphs": [ + { + "header_tapes": [ + 3 + ], + "includes_unreachable_reservation_prefix": true, + "json_bytes": 814873, + "normalized_json_sha256": "86974a12d296ecfdf72a91d894ed2526190bdb3bb96fc16b6ad81faea6b5de6b", + "rank": 1, + "states": 8376 + }, + { + "header_tapes": [ + 3, + 34 + ], + "includes_unreachable_reservation_prefix": true, + "json_bytes": 1643954, + "normalized_json_sha256": "f5d0bd35cf4707b118c33cef85a7fb91d16e1c114e77b56c05b42ed4f1d15bff", + "rank": 1, + "states": 16742 + } + ], + "runtime_header_writes": "No write reachable from declared graph.start; native HEADER is structurally read-only.", + "schema": "borrowed-header-graph-binding/1" +} diff --git a/research/borrowed-header-data-only-home/implementation/NOTICE.md b/research/borrowed-header-data-only-home/implementation/NOTICE.md new file mode 100644 index 0000000000..ef78202ff4 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/NOTICE.md @@ -0,0 +1,20 @@ +# Notice + +Prepared in the CubeJerry integer-multiplication workstream with substantial +OpenAI Codex assistance. Apache-2.0; no independent human/proof-kernel +acceptance. The new wrapper composes supplied literal interfaces and does +not claim new Gaussian, cutoff, frame, tensor or precision mathematics. + +Credit the frozen generic positive central core and its rank-two, literal +phase/CNOT/C-leaf, #6978 and selected-native-tensor-closure predecessors. +Credit B1's permanent-home dispatcher and all unchanged original notices. +Core FREEZE SHA5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef +and all37 retained source files remain unchanged. The separate borrowed +HEADER boundary replaces only the old adapter's inline-header assumption. + +The source motivation and remaining producer/packing obligations are the +frozen selected-common-root-header-gate. The real nine-Gamma root descriptor +is not silently converted into Gamma6. Every supplied native numerical, +layout and cutoff promise remains. No selected assumption or kappa changes. +Earlier packages and shared repositories were not edited. No remote mutation +or publication was performed by this worker. diff --git a/research/borrowed-header-data-only-home/implementation/PR-DRAFT.md b/research/borrowed-header-data-only-home/implementation/PR-DRAFT.md new file mode 100644 index 0000000000..49de62f911 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/PR-DRAFT.md @@ -0,0 +1,26 @@ +# Borrow immutable Gamma6 headers for DATA-only permanent homes + +The existing native HOME adapters put Gamma6||DATA into a common body, so +the body's extent includes the changing header length. Add a literal +fixed-rho wrapper whose HOME contains exactly V scientific DATA bits and +whose distinct supplied Gamma6 HEADER remains immutable. Embed the frozen +positive core unchanged, then check exact returned extent and retire every +private/head/guard before the same-owner B1 scatter. + +Wrapper overhead is at most256(V+1), with64(V+1) added historical backing; +the actual core's full2^24(fV+E+1) time and2048(V+E+1) increment remain. +Both prior larger storage and borrowed header storage stay charged. +F_HOME=V is independent of E; total core cost still charges every header +bit. B1 bank delivery/reservation is separate. + +Two complete f1/rho1 calls physically reuse the same6144-bit HOME and native +banks with two immutable headers supplied at entry (10/268 bits; cutoff +bit lengths1/130). The exact result is C^2's selected-axis swap. Normal and +optimized replays also check cutoff, short DATA, late nonintegrality, +returned-length mismatch and wrong/unfinished scatter. Test monitors are +identified separately from compiled protection. + +Credit the frozen generic core and native/B1 predecessors. No Gamma6 +producer, nine-Gamma root conversion, view packing, cutoff derivation, +all-MOVE/caller admission, faster nonleaf rate, assumption discharge or +new kappa is claimed. No remote publication performed by this worker. diff --git a/research/borrowed-header-data-only-home/implementation/PREFLIGHT.md b/research/borrowed-header-data-only-home/implementation/PREFLIGHT.md new file mode 100644 index 0000000000..aa7a26b00a --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/PREFLIGHT.md @@ -0,0 +1,36 @@ +# Borrowed-header DATA-only HOME preflight + +Canonical e54523517d0f03e58352e647c403a5af3e525a57. The frozen generic positive +core FREEZE SHA is5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef. +It already accepts separate HEADER/DATA owners, preserves HEADER, and returns +DATA under the complete rank-times-f/numerical-prefix promises. Its existing +HOME adapter takes Gamma6||DATA inside HOME and costs/retains E+V there. +The earlier MOVE and signed-ADD HOME adapters also use inline headers. +None of those inspected adapters is this borrowed immutable HEADER plus +DATA-only HOME boundary. This is a bounded interface novelty check, not an +all-code uniqueness claim or new native algebra. + +The real nine-Gamma source descriptor is separate from its DATA. The frozen +selected-common-root-header-gate derives source geometry/precision but does +not produce a Gamma6 view or pack the strided selected bits. Those remain +supplied premises. The new adapter fixes one rho at graph construction and +embeds the unchanged native instruction table offline; no runtime callback, +header production, cutoff derivation, view permutation or selected admission. + +Optimistic wrapper: inject borrowed HEADER at its first Gamma bit, clone +only the V-bit B1 working operand onto private native DATA, run the core, +install exactly V returned bits with simultaneous delimiter/end checks, +and restore all heads/bodies. No new guide is needed: the unchanged operand +delimiter is the extent guide. Core guards are at B-relative1, away from^0. +Borrowed HEADER's native origin is1; other native origins are2. Success +overhead is at most256(V+1), hence O(E+V); wrapper increment at most +64(V+1), in addition to the actual core2048(E+V+1) increment. All old history +and B1 full-bank delivery remain. Header E is not part of F_HOME=V. + +Verification will physically run two rank1 calls using two separately +supplied immutable headers (cutoff1 and a130-bit cutoff) on the same HOME, +same private origins and same V. Both headers exist at entry, so no host +replacement/production step is counted as physical implementation. C^2 is +the selected-axis swap. Exact direct Gaussian numerators provide the oracle. +Cutoff, short DATA, late numerical rejection and faulty return/scatter are +controls; rejected private cleanup/retry is outside the contract. diff --git a/research/borrowed-header-data-only-home/implementation/PROOF.md b/research/borrowed-header-data-only-home/implementation/PROOF.md new file mode 100644 index 0000000000..a5ebe1752c --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/PROOF.md @@ -0,0 +1,218 @@ +# Borrowed immutable HEADER with scientific-DATA-only HOME + +Canonical context: e54523517d0f03e58352e647c403a5af3e525a57. This is a +literal interface composition, not new Gaussian algebra or caller admission. +The unchanged generic positive core is frozen by FREEZE SHA256 +5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef. +Its proof, source closure, exact table hashes and notices are retained. + +## 1. Quantified entry and successful result + +Fix construction-time rho in1..9. Supply a genuinely distinct borrowed +HEADER owner containing `^ Gamma(f)Gamma(r)Gamma(P)Gamma(S)Gamma(w) +Gamma(cutoff)` followed by an arbitrary preserved opaque suffix. Its head +is at the permanent^, relative0; the first Gamma bit is at1. All six +integers are positive and w>=2. E counts every code bit, including an +arbitrarily large cutoff code. HEADER is immutable, not scratch. + +One selected already-reserved B1 HOME contains exactly V binary DATA bits, +with its outside delimiter|. DATA is lexicographic on +`[P] x [2^f]^9 x [S]`, r Gaussian coefficients per address, signed w-bit +MSB-first real then imaginary components on one supplied unchanged grid. +`V=2PSr2^(9f)w`. **F_HOME=V**, independently of E. Every inactive native +slot, spectator range and coefficient is present. Other HOMEs are distinct, +have the same V and may contain arbitrary binary fields/correlated values. + +Retain the core's full numerical promise: rho*f<=cutoff, and every result +of its actual rho*f positive C axes is integral on that grid and fits w +bits. Endpoint fit alone is insufficient. No scale, changed f or rounding +is supplied. The separate Gamma6 producer, root descriptor conversion, +native view permutation, cutoff policy and source occurrence admission +are explicit supplied boundaries. + +At primitive entry operand1 is `^ DATA |` with head at^0, gathered by B1. +Supply native DATA tape4 and29 native private tapes5..33, distinct from +HEADER, HOME, both B1 operands and each other. Each has permanent^0, head +there, and the required positive body/guard windows blank. Prior history +and opaque exteriors remain supplied and charged. The single-header graph +has34 tapes: HOME0, operands1/2, borrowed HEADER3, native DATA4 and private +5..33. An additional borrowed header is an additional fixed public owner, +not private storage available for reuse. + +**Theorem.** The emitted graph executes the unchanged fixed-rho positive +core and returns only its complete scientific DATA to the same original +HOME. HEADER and its entire opaque suffix are unchanged. On success all +heads, private DATA, guards and native guides return/retire exactly; all +permanent markers, other HOMEs and opaque exteriors are preserved. No HOME +write occurs before complete native return, extent-checked private install +and cleanup. Valid-format cutoff/numerical rejection leaves HOME unchanged; +failure cleanup/retry is not claimed. No universal malformed-entry validator +is claimed; correct header/DATA geometry is an entry promise. + +## 2. Exact native injection and origins + +The native ports are HEADER0, DATA1 and private2..30. Map port0 to the fixed +borrowed HEADER h and every t>=1 to3+t. This injection is one-to-one and +uses the full31-tape core. Native HEADER origin is B-relative1. Native DATA +and all private origins are B-relative2; their private guards at origin-1 +are therefore blank B-cell1, away from permanent^0. HEADER is public and +has no native-private guard to write/erase at its origin-1. The core never +writes HEADER; this is also checked structurally before embedding. + +Every retained read/write/unit move/goto/halt becomes the corresponding +Graph rule at a disjoint fixed state label, with ports renamed. Successful +halt is one counted jump to return. Empty scanned-symbol branches remain +rejections. No instruction is replaced by a host callback, arithmetic +service or runtime rank selection. Independent translations of physical +origins preserve local-symbol/unit-move executions, so the proof is not +restricted to the dense verifier's positive origins. + +The B1 fixture starts at graph.execution_start with all homes already +reserved. B1's original unreachable reservation prefix remains in the +serialized table; it is not executed using borrowed HEADER3 as scratch. +The constructor checks every state reachable from the declared entry and +rejects any borrowed-header write. This is a stated entry boundary, not a +claim that the original reservation prelude is compatible with HEADER3. +Typed reservation and marker provisioning remain separately supplied/paid. + +## 3. Clone, complete core, exact return and retirement + +Move native DATA/private heads to relative2 and HEADER to its first bit. +Scan the complete operand from cell1 to its outside|, copying every DATA +bit to native DATA at2. That native stream ends in blank, as required by +the core. Restore operand to^0 and native DATA to2 by local marker scans. +The header has not been parsed/copied/produced by this wrapper. + +The exact native entry now holds. The credited core theorem applies to the +complete arbitrary joint array. It leaves native DATA containing the full +result at origin2, HEADER at its own origin1, and every module-private +bank/guide/guard restored at origin2. The original operand and HOME have +not changed while it ran. The core's own transaction remains unchanged. + +For return, advance operand to its first bit. For each pair of binary +symbols (old operand bit,new native DATA bit), write the new bit into the +operand, erase that native bit, and advance both heads one cell. The only +successful terminal branch requires operand| and native DATA blank +simultaneously. A short or long returned extent cannot pass that branch +or overwrite the operand delimiter. The operand itself is the length +guide; no additional guide tape or input-sized length service is assumed. +The original HOME still has not been written, even if this check rejects. + +Rewind operand and now-erased native DATA to their permanent^ markers. +Move each native-private head from2 back to0 and HEADER from1 back to0. +DATA's rewind crosses its blank guard but never changes^0. All native +guides already retired under the core contract; the wrapper made none. +Only then jump to B1's actual same-owner scatter. B1 copies exactly V bits +back to that HOME, preserves other homes and erases the working operand. +No productive source is created by copying or by the supplied owned field. + +The fixed-rho operator is positive C on all f bits of the first rho slots. +Its exact phase, joint cutoff, central geometry and complete numerical +prefix theorem are credited to the unchanged core, not reproved by the +adapter. In particular replacing header f by rho*f is not performed. + +## 4. Complete bill and retained historical backing + +Count every Graph rule, including terminal tests and gotos, as one fixed +multitape step. Injection preserves the core's instruction count. Before +the core,30 heads move twice, one joint move advances operand/HEADER, +V bits copy, and the two marker rewinds plus DATA's two-cell reposition +take3V+69 steps in total. After the core the paired install, all terminal +tests/rewinds,29 two-cell private returns and HEADER return take3V+66. +Thus wrapper overhead is at most6V+160, below256(V+1). In particular it +is O(E+V) without scanning any descriptor per DATA bit. + +With Setup_rho the fixed program/table/provisioning charge if not already +supplied, the complete primitive bound is + +`T <= Setup_rho + 256(V+1) + 2^24(fV+E+1)`. + +All decoded-parameter arithmetic, encoded cutoff length, C axes, slot swaps, +full-body staging, numerical guards, core head returns and guide retirement +are included in the credited core term. E is not assumed O(V), and numeric +cutoff magnitude is never substituted for its encoded length. At a supplied +fixed f<=q this is O_q(E+V), not O(V) if E can be arbitrarily larger. +The direct fV rate supplies no faster nonleaf tariff. + +Before core entry the wrapper newly visits at most V+2 cells on private +DATA and two cells per native-private owner. Operand and HEADER extents +are supplied/visited at entry. The postlude stays in those windows or +inside the core's actual visited extents. Therefore its additional history +can conservatively be bounded by64(V+1). The source core's unconditional +increment is2048(V+E+1). Consequently, with K_entry the complete retained +history at primitive entry, + +`K_final <= K_entry + 2112(V+E+1)`. + +This is an increment bound: borrowed HEADER storage, earlier larger erased +banks and opaque exteriors remain in K_entry. Reuse takes interval unions +at the same owners/origins; erasure never refunds backing. Changed origins +would additionally require their actual corridors/provisioning. Tests' +reported head spans do not pretend to measure all supplied exterior history. + +B1 full-bank gathering/return, work-operand retirement and initial reservation +are separately paid. With n services, K homes and b operands the retained +dispatcher term is16(n+1)(K+b+1)(V+2), plus the primitive bills. Fixed program +storage/emission is counted separately from varying input execution. Under +a real source's v=V_node/W field normalization, substitute that actual field +volume here; no productive credit is assigned to private/owned fields. + +## 5. Physical unequal-E reuse and negative controls + +The complete fixture has f=r=P=S=1,w=6,V=6144. Random even Gaussian integer +components make each C pass integral and safely fit. Supply two distinct +borrowed headers at initial entry: cutoff1 (E=10) and a130-bit positive +cutoff (E=268). A fixed two-event graph uses the first then the second on +the identical HOME and identical native/private owners and origins. Both +headers exist throughout; no host replacement, producer or omitted mutation +is counted as physical execution. The second public HEADER adds one tape +to this fixture, giving35; a single-header primitive uses34 regardless of E. + +The independent natural-address integer-numerator oracle applies C directly +to the actual first-slot address pairs, rather than following the core's +slot swaps or generated word. Two successful calls give the exact first-slot +C^2 swap. Checks stop after core completion and after private install/cleanup; +HOME changes only at the ensuing B1 same-owner scatter. Both complete headers, +their opaque tails, the other HOME, all heads, private banks and guards are +checked. Actual head moves update visited low/high bounds. Prior larger +history is retained, including when the longer code is consumed. + +Actual-core controls exercise rho2/cutoff1, short DATA and a nonintegral +last address pair, all with zero HOME writes. These are meaningful invalid- +boundary examples, not a guarantee for every malformed stream. Successful +snapshots also drive actual emitted mutants: one dropped returned bit must +fail the paired extent check before HOME scatter; wrong-home return changes +the wrong owner; skipping the private return fails the scientific endpoint. +A wrong-origin mutant is caught by a **test monitor** observing an attempted +write over^0. That monitor is not compiled runtime protection or a premise +of healthy behavior. Rejected private cleanup/retry is unclaimed. + +Source hashes are checked before retained imports. A fresh required-absent +bytecode prefix is set before every project import, so stale pyc cannot +substitute for authenticated source. The retained interpreter is separately +hash-checked. Normal and optimized runs compare the same receipt using +explicit checks, not Python assertions. Finite replays corroborate the +universal composition proof; they are not full large-f DATA executions. + +## 6. Source relation, novelty and open work + +The preceding root-header gate pins the actual nine-Gamma source descriptor, +complete-root factor and source-specific width/P/S equations. It supplies no +six-code producer or packing operation. Its DATA-only observation motivates +this boundary but is not upgraded to a caller theorem. The formal source +descriptor is separate from its DATA; this contribution does not identify +that nine-code owner with the borrowed six-code HEADER. + +The original HOME adapters embed Gamma6||DATA in the body, imposing common +F=E+V. The unchanged native core already separates HEADER and DATA. The +new contribution is their literal borrowed-header/DATA-only HOME composition, +including origins, exact return, owner preservation and full cost/history. +No generic initializer, Gaussian algebra, rank/cutoff theorem or root producer +is claimed new. PREFLIGHT.md and SOURCES.json retain credits and exact pins. + +Open next work: bind an actual source header producer, common-grid prefix +contract, ROW/occurrence view and forward/return packing before attempting +one complete source service. Those are outside this wrapper. All-MOVE +coverage, global selected caller, nonleaf supplier, assumption discharge and +kappa remain outside scope. Prepared with substantial OpenAI Codex assistance, +Apache-2.0; no independent human or formal-kernel acceptance is claimed. diff --git a/research/borrowed-header-data-only-home/implementation/README.md b/research/borrowed-header-data-only-home/implementation/README.md new file mode 100644 index 0000000000..b2dcbd6763 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/README.md @@ -0,0 +1,40 @@ +# Borrowed HEADER, DATA-only HOME + +One literal fixed-rho adapter runs the frozen generic positive core with a +separate supplied immutable Gamma6 HEADER and an already-packed DATA-only +HOME. The body has F_HOME=V, regardless of header length E. On success it +returns only DATA to the identical HOME and restores all private bodies, +guides, guards and heads. Other homes and header/exterior bytes are preserved. + +The core is unchanged. Wrapper overhead is at most256(V+1), with64(V+1) +additional historical backing. Complete primitive bounds are + +`T <= Setup_rho + 256(V+1) + 2^24(fV+E+1)`, +`K_final <= K_entry + 2112(V+E+1)`. + +B1 full-bank delivery/reservation remains separately charged. The graph +starts after HOME reservation; its original reservation prefix is unreachable +from the declared entry and may not use borrowed HEADER3 as scratch. +No header producer, root descriptor conversion, view packing, cutoff policy, +all-MOVE/caller admission, faster nonleaf rate or new kappa is supplied. + +Python3.12+, standard library: + +```sh +python3 -I -W error -B verify.py +python3 -I -O -W error -B verify.py +sha256sum -c CHECKSUMS +``` + +Expected marker: PASS_BORROWED_HEADER_DATA_HOME. Two complete f1/rho1 calls +use the same6144-bit DATA home and private banks, with separate headers of +10 and268 bits supplied at entry. The second cutoff has130 bits. C^2 gives +the exact selected-axis swap. Controls cover cutoff, short DATA, late +nonintegrality, returned-length mismatch and wrong/unfinished scatter. +Failure cleanup/retry and universal malformed-input validation are unclaimed. + +Read PROOF.md for exact entry and origin rules. Header's first Gamma bit is +at B-relative1; native DATA/private origins are2, keeping private guards away +from permanent^0. A single-header graph uses34 fixed tapes; the two-header +fixture uses35. Constructors expand only fixed offline tables, never runtime +parameters or callbacks. The complete unchanged source closure is retained. diff --git a/research/borrowed-header-data-only-home/implementation/RESULT.json b/research/borrowed-header-data-only-home/implementation/RESULT.json new file mode 100644 index 0000000000..79a1e41c68 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/RESULT.json @@ -0,0 +1,339 @@ +{ + "HOME_writes": 12288, + "V_HOME": 6144, + "borrowed_HEADER_writes": [ + 0, + 0 + ], + "core_locations": 8225, + "cutoff_bit_lengths": [ + 1, + 130 + ], + "entry_head_spans": [ + [ + 17, + 12308 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 35 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 24599 + ] + ], + "fault_controls": [ + "late_return_extent_mismatch_before_HOME_scatter", + "wrong_HOME_scatter", + "skipped_private_return", + "test_monitor_detects_guard_over_B_origin" + ], + "final_head_spans": [ + [ + 17, + 12308 + ], + [ + 18, + 6163 + ], + [ + 19, + 19 + ], + [ + 20, + 35 + ], + [ + 21, + 6167 + ], + [ + 22, + 6168 + ], + [ + 23, + 6169 + ], + [ + 17, + 6163 + ], + [ + 18, + 6164 + ], + [ + 19, + 22 + ], + [ + 20, + 290 + ], + [ + 21, + 152 + ], + [ + 22, + 280 + ], + [ + 23, + 26 + ], + [ + 17, + 20 + ], + [ + 18, + 21 + ], + [ + 19, + 22 + ], + [ + 20, + 28 + ], + [ + 21, + 24 + ], + [ + 22, + 25 + ], + [ + 23, + 155 + ], + [ + 17, + 149 + ], + [ + 18, + 21 + ], + [ + 19, + 277 + ], + [ + 20, + 3094 + ], + [ + 21, + 3095 + ], + [ + 22, + 3096 + ], + [ + 23, + 3097 + ], + [ + 17, + 25 + ], + [ + 18, + 26 + ], + [ + 19, + 27 + ], + [ + 20, + 28 + ], + [ + 21, + 31 + ], + [ + 22, + 6168 + ], + [ + 23, + 24599 + ] + ], + "first_commit_and_second_gather_steps": 1250480, + "first_output_sha256": "c04a0a43e393551505afdb0762d19336d3b34e21b550af0145deb10a76cc5a8a", + "header_lengths": [ + 10, + 268 + ], + "history_increment_measured": 56572, + "history_scope": "Entry includes supplied/exterior storage and prior larger history; no erasure refund.", + "input_sha256": "86b1d226b9605eddf6d1d0184b570067297e8b637919d8f09e00a3f50b4cbd3f", + "marker": "PASS_BORROWED_HEADER_DATA_HOME", + "parked_sha256": "b3d93d1707db4d26f4396a2b9e47740966080109478904a4b3caa8c993691f27", + "rank": 1, + "rejections": [ + { + "HOME_writes": 0, + "case": "joint_cutoff", + "steps": 141953 + }, + { + "HOME_writes": 0, + "case": "short_DATA", + "steps": 235276 + }, + { + "HOME_writes": 0, + "case": "late_nonintegral", + "steps": 840859 + } + ], + "reuse_boundary": "Both distinct immutable headers are supplied at initial entry; same HOME and private owners/origins reused. No host header replacement counted as implementation.", + "scope": "Already-packed supplied Gamma6/native view; no producer, view packing, cutoff derivation, all-MOVE/caller or kappa claim.", + "second_output_sha256": "ae5d47dec4823e33a0d63fa2f7e7afd1253fd26e3ef9bea9f71c8945ca0beeb6", + "tapes_single_header": 34, + "tapes_two_header_fixture": 35, + "total_steps": 2452104, + "two_call_graph_states": 16742 +} diff --git a/research/borrowed-header-data-only-home/implementation/SOURCES.json b/research/borrowed-header-data-only-home/implementation/SOURCES.json new file mode 100644 index 0000000000..bc19e261cf --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/SOURCES.json @@ -0,0 +1,290 @@ +{ + "B1": { + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/tape_graph.py", + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "current_source_review": { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "role": "Context; wrapper theorem starts from supplied Gamma6/native view, not the real nine-Gamma input", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + }, + "files": [ + { + "bytes": 1877, + "git_blob": "6f83792ca059bc5aaefeb5697b3a1359545f7b3e", + "local": "inputs/core/CHECKPOINT.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa" + }, + { + "bytes": 468, + "git_blob": "f541f5cbfe9ea1711055b4b27ead9c8f0482d77e", + "local": "inputs/core/ENVIRONMENT.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b" + }, + { + "bytes": 6301, + "git_blob": "b440dc0dec75718f29feb097c5ed2e05d30641fa", + "local": "inputs/core/FREEZE.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef" + }, + { + "bytes": 1756, + "git_blob": "1d452e3c19d0a5e9b9acb3868dd59f572a97b68b", + "local": "inputs/core/NOTICE.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940" + }, + { + "bytes": 2859, + "git_blob": "20e55aad29e30249ffa986286f2625f0b1d7c509", + "local": "inputs/core/OVERLAP.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c" + }, + { + "bytes": 2398, + "git_blob": "614b59012f3ebd1c8bb35148d94bc205d8bf5c81", + "local": "inputs/core/PR-DESCRIPTION.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885" + }, + { + "bytes": 12196, + "git_blob": "3aa9caacf015a39867a4d372b94ca9f11cabf771", + "local": "inputs/core/PROOF.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb" + }, + { + "bytes": 3479, + "git_blob": "98b3a961325252fbd995e6c1c91ee3d35ec0e552", + "local": "inputs/core/README.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c" + }, + { + "bytes": 28741, + "git_blob": "e1ee257cc1ae870cfb544b9a2bac2a0d4b197cbd", + "local": "inputs/core/RESULT.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3" + }, + { + "bytes": 1772, + "git_blob": "39784ed13310cc1f58407553d42496ae4606a2a5", + "local": "inputs/core/SOURCE-BINDING.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232" + }, + { + "bytes": 5445, + "git_blob": "0cf874beeb63ea8f51d210293d34add335b6c349", + "local": "inputs/core/SOURCES.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03" + }, + { + "bytes": 4845, + "git_blob": "8c1f0bed316deb629bc7fbd685a2e43131c10e0b", + "local": "inputs/core/adapter.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534" + }, + { + "bytes": 2850, + "git_blob": "c2dee252131a649f2863dc35612639b3abb17c92", + "local": "inputs/core/bind_sources.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6" + }, + { + "bytes": 6778, + "git_blob": "c1fc922fcc32d271ff463a28fd13fc1a8fb20af6", + "local": "inputs/core/join.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6" + }, + { + "bytes": 6041, + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "local": "inputs/core/machine.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "bytes": 20312, + "git_blob": "5d619cfc2d3b7bc51e6fcc8e7a46ecd1e313e23d", + "local": "inputs/core/reference/pr6978-PROOF.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d" + }, + { + "bytes": 5633, + "git_blob": "f8b32e26117bc678bd8003a4567200783e8496af", + "local": "inputs/core/reference/rank2/FREEZE.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275" + }, + { + "bytes": 16634, + "git_blob": "627e54e031945e3cc269b255669c999a0f5995e3", + "local": "inputs/core/reference/rank2/PROOF.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352" + }, + { + "bytes": 4468, + "git_blob": "04f5dc8367585afbf272ea2ecbb49cd28ce10919", + "local": "inputs/core/reference/rank2/RECIPE.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + }, + { + "bytes": 10337, + "git_blob": "0ea6091131b526591e5757c56c0a50b50b170b83", + "local": "inputs/core/reference/rank2/SOURCES.json", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641" + }, + { + "bytes": 6041, + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "local": "inputs/core/reference/rank2/machine.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "bytes": 8253, + "git_blob": "ed3ef68167456e0322314762dab6eb725d9f3a37", + "local": "inputs/core/reference/rank2/rank2.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a" + }, + { + "bytes": 2093, + "git_blob": "db83fd95e175c90a2f9e51545b4be4557fbb919e", + "local": "inputs/core/reference/rank2/reference/home/NOTICE.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "bytes": 5353, + "git_blob": "10606f87dcfa0781bcae900d95cb86925961d453", + "local": "inputs/core/reference/rank2/reference/home/parent_adapter.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "bytes": 12069, + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7", + "local": "inputs/core/reference/rank2/reference/home/tape_graph.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "bytes": 1900, + "git_blob": "71c5f6dae2c799ce5d76c544e98d1ee7c52ef76c", + "local": "inputs/core/reference/rank2/reference/leaf/NOTICE.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "bytes": 5938, + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72", + "local": "inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 17526, + "git_blob": "bdcc80cbd8b64c601e6d69b7d25ece444b8b1ae2", + "local": "inputs/core/reference/rank2/reference/leaf/leaf.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "bytes": 2180, + "git_blob": "3a3030f23df347c1e45ddf92d2083f89ed16cc67", + "local": "inputs/core/reference/rank2/reference/linear/NOTICE.md", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "bytes": 5938, + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72", + "local": "inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 13102, + "git_blob": "6aad40a6c47ed4415917c86fabbd5227a3819a41", + "local": "inputs/core/reference/rank2/reference/linear/linear.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "bytes": 808, + "git_blob": "7a1f1da9c59d40b1e72905fee5344a8db9ca4353", + "local": "inputs/core/reference/rank2/reference/phase/NOTICE", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "bytes": 5938, + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72", + "local": "inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "bytes": 11734, + "git_blob": "d48978145821fc4a62d534bef2bef9449bda883a", + "local": "inputs/core/reference/rank2/reference/phase/phase.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "bytes": 6824, + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "local": "inputs/core/reference/rank2/reference/source/clifford_exact.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "bytes": 12323, + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "local": "inputs/core/reference/rank2/reference/source/native_verify.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "bytes": 9469, + "git_blob": "c7f1f5131a7ba6cad64cfdc19cd315f6021a31d9", + "local": "inputs/core/verify.py", + "role": "unchanged frozen generic-core source/proof closure", + "sha256": "b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471" + }, + { + "bytes": 6041, + "local": "machine.py", + "role": "unchanged retained interpreter; hash checked before import", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + } + ], + "generic_core_FREEZE_sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "generic_core_original": "worker-a/research/generic-positive-native-join-gate", + "motivating_dependency_gate": { + "manifest_sha256": "eb33e328a4a9ef9eab08bb1d6fef30a5bc23609841a741119a598d80bc02d86b", + "path": "worker-b/research/selected-common-root-header-gate/GATE.md", + "role": "Source descriptor/layout motivation only; no producer assumed implemented", + "sha256": "578eebb059144bcc44aac943be646d63a445211ef832c9ee60cdd6e771d1f6d4" + }, + "scope": "New borrowed-header/DATA-only HOME adapter; no changed native instructions or producer/caller claim." +} diff --git a/research/borrowed-header-data-only-home/implementation/adapter.py b/research/borrowed-header-data-only-home/implementation/adapter.py new file mode 100644 index 0000000000..060ed0b228 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/adapter.py @@ -0,0 +1,140 @@ +"""Borrow immutable Gamma6 HEADER; DATA-only B1 HOME. Offline constructors. +Apache-2.0; prepared with substantial OpenAI Codex assistance. +""" +from pathlib import Path +from hashlib import sha256 +from functools import cache +import atexit +import importlib.util +import json +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +_cache = tempfile.TemporaryDirectory(prefix='borrowed-header-import-') +atexit.register(_cache.cleanup) +sys.dont_write_bytecode = True +sys.pycache_prefix = str(Path(_cache.name)/'required-absent') +if Path(sys.pycache_prefix).exists(): + raise ValueError('cache isolation prefix must be absent') +CORE = HERE/'inputs/core' +freeze = (CORE/'FREEZE.json').read_bytes() +if sha256(freeze).hexdigest() != '5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef': + raise ValueError('generic positive freeze drift') +for pin in json.loads(freeze)['files']: + raw = (CORE/pin['path']).read_bytes() + if len(raw) != pin['bytes'] or sha256(raw).hexdigest() != pin['sha256']: + raise ValueError('frozen generic source drift: '+pin['path']) + +def load(name,path): + spec = importlib.util.spec_from_file_location(name,path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + +C = load('borrowed_positive_core',CORE/'join.py') +D = C.load('borrowed_home_dispatch',CORE/'reference/rank2/reference/home/tape_graph.py') +DATA, LAST, TAPES = 4,33,34 +OWNERS = (('parked-productive',0),('supplied-native-data',0)) + +@cache +def core(rank): + code, alphabet, entries = C.compile_join(rank) + pin = next(x for x in json.loads((CORE/'SOURCE-BINDING.json').read_text())['core_tables'] if x['rank'] == rank) + if alphabet != ('_','0','1','|') or len(code) != pin['locations'] or sha256(repr(code).encode()).hexdigest() != pin['sha256']: + raise ValueError('actual generic native table drift') + if any(op == 'write' and args[0] == 0 for op,*args in code): + raise ValueError('borrowed HEADER must be immutable') + return code + +def step(g,tape,count,target): + for _ in range(abs(count)): + target = g.jump(target,((tape,1 if count>0 else -1),)) + return target + +def embed(g,code,after,header_tape): + labels = [g.state('POSITIVE') for _ in code] + port = lambda t: header_tape if t == 0 else 3+t + for pc,(op,*args) in enumerate(code): + state = labels[pc] + g.rules.setdefault(state,[]) + nxt = labels[pc+1] if pc+1=2`, and canonical header +`Gamma(f) Gamma(c) Gamma(P) Gamma(S) Gamma(w) Gamma(cutoff)` of full length E. +c is Gaussian coefficient multiplicity, distinct from rho. DATA is the +complete lexicographic array `[P] x [2^f]^9 x [S]`, with c coefficients at +each address, real then imaginary, each component signed w-bit MSB-first. +Thus `V=2 P S c 2^(9f) w`, `F=E+V`. Its common quantum is supplied and fixed. + +Require `rho*f<=cutoff`, and require every intermediate result of the actual +rho*f positive C axes to be Gaussian-integral on that grid and fit signed +w bits. Owners are distinct, heads start at origins, required private +bodies/guards are blank, and opaque exteriors/old backing remain separately +supplied. Malformed streams are outside this entry contract. + +**Theorem.** One emitted31-tape four-symbol local program per fixed rho +returns exactly `product_(slot0, the three-CNOT word +`(0<-0 xor i),(i<-i xor0),(0<-0 xor i)` exchanges slots0 and i. The +unchanged generic `cnot_columns(target,control)` applies each gate to all +corresponding f columns. Its inherited proof covers any distinct fixed +pair in0..8. The word sends (a,b) to (b,a), preserving other coordinates, +and has no Gaussian phase. Write this permutation Si. Exactly `Si C0 Si=Ci`. + +Chronologically the program executes joint guard,C0, then Si,C0,Si for +i=1..rho-1, then commit/retirement. The Ci act on disjoint bits and commute. +This is positive C on all rho*f requested axes, including the factor1/2 +and absolute phase. It is not projective equality. Every factor uses the +original header for full prefix/middle/suffix/component strides; all P/S, +c coefficients and inactive native bits remain complete spectators. The +all-f tensor statement follows from these individual coordinate operators, +not by tensor-powering a register scalar sum. + +## 3. Literal rank-times-f guard + +Let n be f's bit length, `q=ceil(log2(rho))`, with q=0 at rho1. Prefix FBIN +with q zero digits before the unchanged Gamma parser appends f's canonical +n MSB-first bits. The same parser retains original unary F and n marks on +FLEN. The public header is read-only throughout. + +Clear FLEN and scan FBIN from its low end. Fixed carry a in0..rho-1 on +digit b writes `(rho*b+a) mod2` and changes to `floor((rho*b+a)/2)`. +Induction on processed low digits proves multiplication. Every new carry +stays in0..rho-1. Since rho<=2^q and f<2^n, the product fits n+q positions. +The carry at the original left marker is therefore zero. A nonzero carry +there rejects; no left guard or opaque neighbor is overwritten/crossed. + +Skip/erase leading product zeros; copy the positive canonical suffix to +PREFIX while rebuilding FLEN and erasing old FBIN. Return FBIN across its +now blank body and move PREFIX back into it, erasing PREFIX. FBIN/FLEN now +hold canonical rho*f and its length at the original origins. The product +has n..n+q digits, so at most q leading zeros are skipped. Unary F remains f. +The loops are literal fixed-state operations; no host decoding occurs. + +Decode c,P,S,w using the inherited parser. Read cutoff only as binary +digits/length. The retained length-first and lexicographic comparison now +tests rho*f<=cutoff, clears its binary guides, and returns. Restore HEADER +with its trace; clear all other guides and local markers. In particular, +an arbitrarily large encoded cutoff is charged by E, never its numeric value. + +## 4. Transaction and inherited-helper invariants + +The core clones original DATA once to WORK and restores its original head +using TRACE. Immutable rank2 `insert` maps component HEADER port0 to original +HEADER, component DATA port1 to WORK, and private t>=2 to t+2. Program +counters get disjoint fixed labels and successful halts become local gotos +to the next component. Every emitted operation is read/write/unit move/goto +or halt. Leaf port28 maps to30, so31 tapes suffice independently of rho/f. + +On successful return the new guard leaves module scratch blank at origins. +Each inherited leaf and swap word has the same invariant: original HEADER +and its DATA at their origins, module-private bodies/guards erased, opaque +exterior preserved. All components can therefore reuse the same27 private +owners. Their commits affect only WORK. No owner is created per column/slot. + +After every requested axis succeeds, one V-bit final commit writes original +DATA, erases WORK and records/restores heads. WORK/TRACE markers retire. +This is the frozen rank2 outer transaction. The table checker independently +confirms no original DATA WRITE before the final commit in all nine graphs. + +HOME splits exactly six Gamma codes and complete DATA onto native private +tapes at B-relative2, retaining a blank guard at1 and permanent^ at0. Ports +map injectively to3..33; GUIDE is34. On success header/data copy back to +the complete operand, split copies erase and all35 heads return to B origins. +B1 scatters exactly F bits to the same immutable HOME. The parked fixture +is preserved; the owned field gains no productive credit. Typed creation, +placement, later scalar services and full caller remain outside the module. + +## 5. Exact numerical promises + +Permutations preserve every signed component, including its minimum. The +concrete leaf uses w+2-bit temporary numerator rows and actual exact-half +and signed-range guards. Invoke that proved domain at every C stage: +intermediate integrality/fit, not merely final fit. No scale, widened header, +rounding, precision producer or promise checker is supplied here. + +One elementary sufficient reserve is that original components are divisible +by2^(rho*f), bounded by M, and `2^(rho*f) M <= 2^(w-1)-1`. A C row is a +four-term signed sum divided by2: each axis spends at most one divisibility +bit and grows component maximum by at most2. Induction proves all prefix +promises. The exact admitted domain is larger. This reserve is not a new +norm theorem or an assertion about an actual selected producer. + +## 6. Complete direct-leaf bill and historical backing + +All local reads/writes/unit moves/gotos/halts cost one. Let +`Z=f+c+P+S+w<=5V`. Inherited Gamma conversions, trace work and final clears +have the same envelopes as the frozen rank2 proof. The new multiplication, +including its q leading writes, clear, forward/backward scans, canonical +copy/length, move-back and every rewind, costs at most64(n+q+1). For example +expanding the loops gives at most43n+38q+27. Padding also lengthens Gamma's +final captured-FBIN rewind by3q transitions. Charging that explicitly gives +43n+41q+27, still below64(n+q+1). Since n<=E,q<=4 this fits128(E+1). +The total guard fits1024(E+Z+1), below the reserved +**65536(V+E+1)**. Its visited increment is below6V+10E+100, hence below +64(V+E+1) on this positive nine-slot domain; the extra product prefix is +at most E+4 cells and no opaque boundary is traversed. + +Complete inherited bounds, including descriptors, cloning/commit, seeks, +arithmetic and retirement, are + +`T_G(k)<=1024 k f(V+1)+8192(V+E+1)`, +`T_C<=65536(fV+E+1)`. + +There are rho leaves and2(rho-1) swap words of k=3. The outer transaction +costs31V+27. Adding everything gives + +`65536(V+E+1)+65536rho(fV+E+1)` +` +6144(rho-1)f(V+1)+16384(rho-1)(V+E+1)+31V+27`. + +Using f(V+1)<=2fV and V<=fV gives + +`(94208rho+36895)fV+(81920rho+49152)E+(81920rho+49179)`. + +At rho<=9 the coefficients are bounded by884767,786432,786459. The +registered2^24 envelope covers them separately. No child, swap, conversion, +return, full-body copy or helper retirement is paid implicitly. + +Guard and every leaf/word each have64(V+E+1) incremental visited backing; +WORK/TRACE adds8(V+E+1). Sum increments rather than refund retired factors: + +`[64+64rho+128(rho-1)+8](V+E+1)` +`=(192rho-56)(V+E+1)<=1672(V+E+1)<2048(V+E+1)`. + +Older history remains in K_entry. Smaller successful calls at fixed origins +can reuse blank bodies while retaining old maxima. Changed origins require +actual interval unions and paid corridors. Adapter128(F+1)/64(F+1), B1 +full-bank work and fixed setup/program storage remain separately charged. + +This is direct O_r(fV+E). At a genuinely fixed active-axis cutoff q, +rho*f<=q makes it O_q(F+1), while full E stays charged. No faster selected +nonleaf monomial tariff follows and the prior serial-column gate is intact. + +## 7. Evidence and remaining interface + +All nine tables are checked for alphabet, port/PC bounds, unit moves and +no early original DATA write. There are233 physical guard cases: ranks1..9, +f=1,2,3,5,16,65,129, cutoff immediately below/at/above rho*f when positive, +plus64/258/513/1025/4097-bit cutoff syntax at signed distinct origins. These +are header tests, not full large-f DATA runs. Every success restores all +guard private bytes/heads and preserves original header/exteriors. + +A complete f1,rho3 dense nonzero Gaussian packet spans all512 addresses. +The oracle applies the C formula directly to actual slot bits, without +simulating the emitted swaps. Exact output returns in13663028 steps, with +8206 HOME writes only after complete primitive return. All35 heads, private +bodies/guards/exteriors restore. An actually executed omitted-third-C graph +returns a different rank-two tensor answer. The legal-format cutoff f1,t2 +rejects in189419 steps with zero public writes; a weak old-f guard physically +accepts its header. An actually changed retained leaf byte fails source +authentication. Normal and optimized replay are required. + +This is a central primitive, not a complete MOVE. Surrounding arbitrary +affine translations, linear/quadratic/global phases, binary maps, exact +source/frame orientation, ownership, grid producers, nonleaf rates and +caller placement remain. No all-source MOVE family, recursive substitution, +owned lifetime or foundational assumption is discharged by this package. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/README.md b/research/borrowed-header-data-only-home/implementation/inputs/core/README.md new file mode 100644 index 0000000000..98b3a96132 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/README.md @@ -0,0 +1,57 @@ +# Literal positive central join at each fixed native rank1..9 + +This package emits one complete fixed-tape positive central leaf for each +fixed rank rho=1..9 and arbitrary encoded column count f, in the existing +six-Gamma/HOME ABI. The actual joint guard is **rho*f<=cutoff**. Every leaf +and slot swap receives the original f and retains the complete9f geometry. +No width-changing view is supplied to a nine-slot numerical consumer. + +The central operator is positive C on all f bits of the first rho native +slots, with exact phase and unchanged quantum. One original-owner transaction +encloses rho first-slot C passes and6(rho-1) CNOTs implementing slot swaps. +All helpers, copying, descriptor scans, return and retirement are paid. +The core uses31 tapes; the supplied owned HOME layer uses35. For complete +bit lengths `V=2PSc2^(9f)w`, E and F=E+V, successful runtime satisfies + +`T_core<=2^24(fV+E+1)`, `K_final<=K_entry+2048(V+E+1)`. + +HOME adds128(F+1) time and64(F+1) backing. General B1 bank access, fixed +setup/program storage and caller creation/placement remain separate charges. +Every actual intermediate C prefix must be integral and fit the supplied +signed width; final fit alone is insufficient. No scale, width conversion +or rounding is installed. + +PR #6978 already proves the rank-times-column algebra, positive orientation, +cutoff and coded child; `selected-native-tensor-closure` proves the selected +all-column algebra. The contribution here is a literal uniform-rank +Gamma6/HOME numerical lifecycle export, extending the frozen literal rank2 +mechanism. It is a central primitive, not a complete generic MOVE. It does +not satisfy the faster nonleaf tariff, identify an actual caller, implement +all source monomials, or discharge a global assumption. See PROOF.md and +OVERLAP.md for the exact source/claim boundaries. + +Reproduce with the Python standard library, in about11 seconds per run: + +```sh +python -B /workspace/scratch/92c9920affc2/worker-a/research/generic-positive-native-join-gate/verify.py +python -O -B /workspace/scratch/92c9920affc2/worker-a/research/generic-positive-native-join-gate/verify.py +python -B /workspace/scratch/92c9920affc2/worker-a/research/generic-positive-native-join-gate/bind_sources.py --source-repo /workspace/scratch/92c9920affc2/repo +``` + +The checker authenticates immutable sources before retained imports, with +fresh bytecode-cache isolation. It checks all nine table families,233 literal +guard headers at signed distinct origins including4097-bit cutoff syntax, +and a complete nonzero f1/rho3 packet against direct actual-axis butterflies. +It verifies all35 heads/private bodies/exteriors, public safety on cutoff, +and an actually executed omitted-third-C graph. Large header cases do not +constitute full large-f numerical execution. `--write` refreshes RESULT.json. +The source-binding command checks21 retained pins,15 original Git blobs, +the canonical prior proof and all nine regenerated tables. SOURCE-BINDING.json +also pins the complete rank3 HOME graph by normalized JSON SHA256. + +Open next questions are the source-specific complete monomial/HOME join +(including affine offsets and nonzero global phases), actual typed source +binding/producer promises, endpoint format conversion where needed, and +separately the selected nonleaf rate. The fixed9-axis source census is being +reviewed independently; this package does not duplicate it or infer all-MOVE +coverage from its rank range. Earlier frozen packages are untouched. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/RESULT.json b/research/borrowed-header-data-only-home/implementation/inputs/core/RESULT.json new file mode 100644 index 0000000000..e1ee257cc1 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/RESULT.json @@ -0,0 +1,1722 @@ +{ + "controls": [ + "joint cutoff versus weak f cutoff", + "actual omitted third C", + "actual retained source corruption", + "no early original-owner write" + ], + "core_tapes": 31, + "cutoff_rejection_steps": 189419, + "guard_cases": [ + { + "accepted": true, + "cutoff_bits": 1, + "f": 1, + "rank": 1, + "steps": 1244 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 1, + "rank": 1, + "steps": 1274 + }, + { + "accepted": false, + "cutoff_bits": 1, + "f": 2, + "rank": 1, + "steps": 852 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 2, + "rank": 1, + "steps": 1479 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 2, + "rank": 1, + "steps": 1468 + }, + { + "accepted": false, + "cutoff_bits": 2, + "f": 3, + "rank": 1, + "steps": 924 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 3, + "rank": 1, + "steps": 1503 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 3, + "rank": 1, + "steps": 1522 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 5, + "rank": 1, + "steps": 1145 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 5, + "rank": 1, + "steps": 1792 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 5, + "rank": 1, + "steps": 1770 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 16, + "rank": 1, + "steps": 1858 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 16, + "rank": 1, + "steps": 2778 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 16, + "rank": 1, + "steps": 2767 + }, + { + "accepted": false, + "cutoff_bits": 7, + "f": 65, + "rank": 1, + "steps": 4473 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 65, + "rank": 1, + "steps": 5756 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 65, + "rank": 1, + "steps": 5734 + }, + { + "accepted": false, + "cutoff_bits": 8, + "f": 129, + "rank": 1, + "steps": 7608 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 129, + "rank": 1, + "steps": 9393 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 129, + "rank": 1, + "steps": 9371 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 1, + "steps": 4740 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 1, + "steps": 14246 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 1, + "steps": 26741 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 1, + "steps": 51829 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 1, + "steps": 202357 + }, + { + "accepted": false, + "cutoff_bits": 1, + "f": 1, + "rank": 2, + "steps": 760 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 1, + "rank": 2, + "steps": 1370 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 1, + "rank": 2, + "steps": 1359 + }, + { + "accepted": false, + "cutoff_bits": 2, + "f": 2, + "rank": 2, + "steps": 923 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 2, + "rank": 2, + "steps": 1605 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 2, + "rank": 2, + "steps": 1594 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 3, + "rank": 2, + "steps": 1001 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 3, + "rank": 2, + "steps": 1629 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 3, + "rank": 2, + "steps": 1618 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 5, + "rank": 2, + "steps": 1222 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 5, + "rank": 2, + "steps": 1918 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 5, + "rank": 2, + "steps": 1907 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 16, + "rank": 2, + "steps": 1929 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 16, + "rank": 2, + "steps": 2904 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 16, + "rank": 2, + "steps": 2893 + }, + { + "accepted": false, + "cutoff_bits": 8, + "f": 65, + "rank": 2, + "steps": 4550 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 65, + "rank": 2, + "steps": 5882 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 65, + "rank": 2, + "steps": 5871 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 129, + "rank": 2, + "steps": 7685 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 129, + "rank": 2, + "steps": 9519 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 129, + "rank": 2, + "steps": 9508 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 2, + "steps": 4806 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 2, + "steps": 14312 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 2, + "steps": 26807 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 2, + "steps": 51895 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 2, + "steps": 202423 + }, + { + "accepted": false, + "cutoff_bits": 2, + "f": 1, + "rank": 3, + "steps": 834 + }, + { + "accepted": true, + "cutoff_bits": 2, + "f": 1, + "rank": 3, + "steps": 1389 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 3, + "steps": 1408 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 2, + "rank": 3, + "steps": 1003 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 2, + "rank": 3, + "steps": 1624 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 2, + "rank": 3, + "steps": 1613 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 3, + "rank": 3, + "steps": 1088 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 3, + "rank": 3, + "steps": 1755 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 3, + "rank": 3, + "steps": 1733 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 5, + "rank": 3, + "steps": 1246 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 5, + "rank": 3, + "steps": 1937 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 3, + "steps": 1934 + }, + { + "accepted": false, + "cutoff_bits": 6, + "f": 16, + "rank": 3, + "steps": 2027 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 16, + "rank": 3, + "steps": 2923 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 16, + "rank": 3, + "steps": 2912 + }, + { + "accepted": false, + "cutoff_bits": 8, + "f": 65, + "rank": 3, + "steps": 4574 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 65, + "rank": 3, + "steps": 5901 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 65, + "rank": 3, + "steps": 5868 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 129, + "rank": 3, + "steps": 7709 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 129, + "rank": 3, + "steps": 9538 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 129, + "rank": 3, + "steps": 9505 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 3, + "steps": 4825 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 3, + "steps": 14331 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 3, + "steps": 26826 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 3, + "steps": 51914 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 3, + "steps": 202442 + }, + { + "accepted": false, + "cutoff_bits": 2, + "f": 1, + "rank": 4, + "steps": 831 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 4, + "steps": 1496 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 4, + "steps": 1485 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 2, + "rank": 4, + "steps": 994 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 4, + "steps": 1731 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 4, + "steps": 1720 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 3, + "rank": 4, + "steps": 1078 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 3, + "rank": 4, + "steps": 1755 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 3, + "rank": 4, + "steps": 1744 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 5, + "rank": 4, + "steps": 1299 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 4, + "steps": 2044 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 4, + "steps": 2033 + }, + { + "accepted": false, + "cutoff_bits": 6, + "f": 16, + "rank": 4, + "steps": 2000 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 4, + "steps": 3030 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 4, + "steps": 3019 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 65, + "rank": 4, + "steps": 4627 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 4, + "steps": 6008 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 4, + "steps": 5997 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 129, + "rank": 4, + "steps": 7762 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 4, + "steps": 9645 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 4, + "steps": 9634 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 4, + "steps": 4872 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 4, + "steps": 14378 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 4, + "steps": 26873 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 4, + "steps": 51961 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 4, + "steps": 202489 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 1, + "rank": 5, + "steps": 916 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 5, + "steps": 1515 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 5, + "steps": 1493 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 2, + "rank": 5, + "steps": 1085 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 5, + "steps": 1750 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 5, + "steps": 1739 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 3, + "rank": 5, + "steps": 1107 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 3, + "rank": 5, + "steps": 1774 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 5, + "steps": 1771 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 5, + "rank": 5, + "steps": 1328 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 5, + "steps": 2063 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 5, + "steps": 2041 + }, + { + "accepted": false, + "cutoff_bits": 7, + "f": 16, + "rank": 5, + "steps": 2109 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 5, + "steps": 3049 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 5, + "steps": 3038 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 65, + "rank": 5, + "steps": 4656 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 5, + "steps": 6027 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 5, + "steps": 6005 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 129, + "rank": 5, + "steps": 7791 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 5, + "steps": 9664 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 5, + "steps": 9642 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 5, + "steps": 4891 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 5, + "steps": 14397 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 5, + "steps": 26892 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 5, + "steps": 51980 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 5, + "steps": 202508 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 1, + "rank": 6, + "steps": 911 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 6, + "steps": 1515 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 6, + "steps": 1504 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 2, + "rank": 6, + "steps": 1080 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 6, + "steps": 1750 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 6, + "steps": 1739 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 3, + "rank": 6, + "steps": 1165 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 6, + "steps": 1881 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 6, + "steps": 1870 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 5, + "rank": 6, + "steps": 1323 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 6, + "steps": 2063 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 5, + "rank": 6, + "steps": 2052 + }, + { + "accepted": false, + "cutoff_bits": 7, + "f": 16, + "rank": 6, + "steps": 2104 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 6, + "steps": 3049 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 6, + "steps": 3038 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 65, + "rank": 6, + "steps": 4651 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 6, + "steps": 6027 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 6, + "steps": 6016 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 129, + "rank": 6, + "steps": 7786 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 6, + "steps": 9664 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 6, + "steps": 9653 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 6, + "steps": 4891 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 6, + "steps": 14397 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 6, + "steps": 26892 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 6, + "steps": 51980 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 6, + "steps": 202508 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 1, + "rank": 7, + "steps": 916 + }, + { + "accepted": true, + "cutoff_bits": 3, + "f": 1, + "rank": 7, + "steps": 1515 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 1, + "rank": 7, + "steps": 1523 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 2, + "rank": 7, + "steps": 1085 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 7, + "steps": 1750 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 2, + "rank": 7, + "steps": 1739 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 3, + "rank": 7, + "steps": 1170 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 7, + "steps": 1881 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 7, + "steps": 1859 + }, + { + "accepted": false, + "cutoff_bits": 6, + "f": 5, + "rank": 7, + "steps": 1391 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 7, + "steps": 2170 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 7, + "steps": 2137 + }, + { + "accepted": false, + "cutoff_bits": 7, + "f": 16, + "rank": 7, + "steps": 2109 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 7, + "steps": 3049 + }, + { + "accepted": true, + "cutoff_bits": 7, + "f": 16, + "rank": 7, + "steps": 3038 + }, + { + "accepted": false, + "cutoff_bits": 9, + "f": 65, + "rank": 7, + "steps": 4656 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 7, + "steps": 6027 + }, + { + "accepted": true, + "cutoff_bits": 9, + "f": 65, + "rank": 7, + "steps": 5983 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 129, + "rank": 7, + "steps": 7791 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 7, + "steps": 9664 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 129, + "rank": 7, + "steps": 9620 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 7, + "steps": 4938 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 7, + "steps": 14444 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 7, + "steps": 26939 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 7, + "steps": 52027 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 7, + "steps": 202555 + }, + { + "accepted": false, + "cutoff_bits": 3, + "f": 1, + "rank": 8, + "steps": 902 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 1, + "rank": 8, + "steps": 1622 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 1, + "rank": 8, + "steps": 1611 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 2, + "rank": 8, + "steps": 1065 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 2, + "rank": 8, + "steps": 1857 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 2, + "rank": 8, + "steps": 1846 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 3, + "rank": 8, + "steps": 1155 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 8, + "steps": 1881 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 8, + "steps": 1870 + }, + { + "accepted": false, + "cutoff_bits": 6, + "f": 5, + "rank": 8, + "steps": 1376 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 8, + "steps": 2170 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 8, + "steps": 2159 + }, + { + "accepted": false, + "cutoff_bits": 7, + "f": 16, + "rank": 8, + "steps": 2071 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 16, + "rank": 8, + "steps": 3156 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 16, + "rank": 8, + "steps": 3145 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 65, + "rank": 8, + "steps": 4704 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 65, + "rank": 8, + "steps": 6134 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 65, + "rank": 8, + "steps": 6123 + }, + { + "accepted": false, + "cutoff_bits": 11, + "f": 129, + "rank": 8, + "steps": 7839 + }, + { + "accepted": true, + "cutoff_bits": 11, + "f": 129, + "rank": 8, + "steps": 9771 + }, + { + "accepted": true, + "cutoff_bits": 11, + "f": 129, + "rank": 8, + "steps": 9760 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 8, + "steps": 4938 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 8, + "steps": 14444 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 8, + "steps": 26939 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 8, + "steps": 52027 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 8, + "steps": 202555 + }, + { + "accepted": false, + "cutoff_bits": 4, + "f": 1, + "rank": 9, + "steps": 998 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 1, + "rank": 9, + "steps": 1641 + }, + { + "accepted": true, + "cutoff_bits": 4, + "f": 1, + "rank": 9, + "steps": 1619 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 2, + "rank": 9, + "steps": 1167 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 2, + "rank": 9, + "steps": 1876 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 2, + "rank": 9, + "steps": 1865 + }, + { + "accepted": false, + "cutoff_bits": 5, + "f": 3, + "rank": 9, + "steps": 1189 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 9, + "steps": 1900 + }, + { + "accepted": true, + "cutoff_bits": 5, + "f": 3, + "rank": 9, + "steps": 1867 + }, + { + "accepted": false, + "cutoff_bits": 6, + "f": 5, + "rank": 9, + "steps": 1410 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 9, + "steps": 2189 + }, + { + "accepted": true, + "cutoff_bits": 6, + "f": 5, + "rank": 9, + "steps": 2167 + }, + { + "accepted": false, + "cutoff_bits": 8, + "f": 16, + "rank": 9, + "steps": 2191 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 16, + "rank": 9, + "steps": 3175 + }, + { + "accepted": true, + "cutoff_bits": 8, + "f": 16, + "rank": 9, + "steps": 3164 + }, + { + "accepted": false, + "cutoff_bits": 10, + "f": 65, + "rank": 9, + "steps": 4738 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 65, + "rank": 9, + "steps": 6153 + }, + { + "accepted": true, + "cutoff_bits": 10, + "f": 65, + "rank": 9, + "steps": 6131 + }, + { + "accepted": false, + "cutoff_bits": 11, + "f": 129, + "rank": 9, + "steps": 7873 + }, + { + "accepted": true, + "cutoff_bits": 11, + "f": 129, + "rank": 9, + "steps": 9790 + }, + { + "accepted": true, + "cutoff_bits": 11, + "f": 129, + "rank": 9, + "steps": 9768 + }, + { + "accepted": true, + "cutoff_bits": 64, + "f": 5, + "rank": 9, + "steps": 4957 + }, + { + "accepted": true, + "cutoff_bits": 258, + "f": 5, + "rank": 9, + "steps": 14463 + }, + { + "accepted": true, + "cutoff_bits": 513, + "f": 5, + "rank": 9, + "steps": 26958 + }, + { + "accepted": true, + "cutoff_bits": 1025, + "f": 5, + "rank": 9, + "steps": 52046 + }, + { + "accepted": true, + "cutoff_bits": 4097, + "f": 5, + "rank": 9, + "steps": 202574 + } + ], + "marker": "PASS_LITERAL_GENERIC_POSITIVE_HOME", + "omitted_child_steps": 12456520, + "rank_three": { + "E": 14, + "F": 8206, + "HOME_writes": 8206, + "V": 8192, + "core_return_steps": 13597300, + "output_sha256": "55bd574610defec258ca41ded3d8c7cc68ae3cd4b5bd144a1d9402d72e296b88", + "retained_old_guide_high": 24641, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 3 + ], + "steps": 13663028, + "visited_increment": 110737 + }, + "scope": "fixed-rank positive central direct leaf only; no surrounding monomials/caller/nonleaf rate", + "tables": [ + { + "commit": 8191, + "locations": 8225, + "rank": 1, + "sha256": "538e1dc21b73c4e123d838bb0c01570db9811f5bc6963ff47a122d359e631da9" + }, + { + "commit": 25208, + "locations": 25242, + "rank": 2, + "sha256": "c4d8abeb423b1f094d813916331d1fd89a905536a24b9719d450296f1f1fcabb" + }, + { + "commit": 42225, + "locations": 42259, + "rank": 3, + "sha256": "7e6eed2526b464b330e2d7b8b1191505f8acbcbe286d4409ef98f4f52c391275" + }, + { + "commit": 59240, + "locations": 59274, + "rank": 4, + "sha256": "f99dbf917f6a1425fdbb578eeaae6aecd3f92d4487628309ecc1b7f493769921" + }, + { + "commit": 76257, + "locations": 76291, + "rank": 5, + "sha256": "477bebd1519f110e93d1f8c9f4c195d9148ba69690639c2144e3aae53b1b3c8b" + }, + { + "commit": 93272, + "locations": 93306, + "rank": 6, + "sha256": "562fea10655e71d195d17fc23bcff4d35b0ae43f817eccb4a13da06120b842dd" + }, + { + "commit": 110287, + "locations": 110321, + "rank": 7, + "sha256": "b86dbd635d8ad30b09ac3578f20f8b00fa463f94246b2ebe7b8ae729086f4618" + }, + { + "commit": 127302, + "locations": 127336, + "rank": 8, + "sha256": "48bc869765f4c115b06cb3e55c492f21261c83586efc894cb744bf0f9bd512be" + }, + { + "commit": 144319, + "locations": 144353, + "rank": 9, + "sha256": "ea01f37d6d43bf2e5266c0789a0049f15b041d339798b5d5036d1b9c51f55c0c" + } + ], + "tapes": 35 +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCE-BINDING.json b/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCE-BINDING.json new file mode 100644 index 0000000000..39784ed133 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCE-BINDING.json @@ -0,0 +1,65 @@ +{ + "status": "PASS", + "retained_pins": 21, + "original_git_blobs": 15, + "canonical_prior_proof_checked": true, + "rank_three_HOME_states": 42436, + "rank_three_HOME_json_bytes": 2858241, + "rank_three_HOME_sha256": "5cb2c76e63c4ced7ab5500814e062e290272792b4631ad5da2e975fed014dc30", + "core_tables": [ + { + "commit": 8191, + "locations": 8225, + "rank": 1, + "sha256": "538e1dc21b73c4e123d838bb0c01570db9811f5bc6963ff47a122d359e631da9" + }, + { + "commit": 25208, + "locations": 25242, + "rank": 2, + "sha256": "c4d8abeb423b1f094d813916331d1fd89a905536a24b9719d450296f1f1fcabb" + }, + { + "commit": 42225, + "locations": 42259, + "rank": 3, + "sha256": "7e6eed2526b464b330e2d7b8b1191505f8acbcbe286d4409ef98f4f52c391275" + }, + { + "commit": 59240, + "locations": 59274, + "rank": 4, + "sha256": "f99dbf917f6a1425fdbb578eeaae6aecd3f92d4487628309ecc1b7f493769921" + }, + { + "commit": 76257, + "locations": 76291, + "rank": 5, + "sha256": "477bebd1519f110e93d1f8c9f4c195d9148ba69690639c2144e3aae53b1b3c8b" + }, + { + "commit": 93272, + "locations": 93306, + "rank": 6, + "sha256": "562fea10655e71d195d17fc23bcff4d35b0ae43f817eccb4a13da06120b842dd" + }, + { + "commit": 110287, + "locations": 110321, + "rank": 7, + "sha256": "b86dbd635d8ad30b09ac3578f20f8b00fa463f94246b2ebe7b8ae729086f4618" + }, + { + "commit": 127302, + "locations": 127336, + "rank": 8, + "sha256": "48bc869765f4c115b06cb3e55c492f21261c83586efc894cb744bf0f9bd512be" + }, + { + "commit": 144319, + "locations": 144353, + "rank": 9, + "sha256": "ea01f37d6d43bf2e5266c0789a0049f15b041d339798b5d5036d1b9c51f55c0c" + } + ] +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCES.json b/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCES.json new file mode 100644 index 0000000000..0cf874beeb --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/SOURCES.json @@ -0,0 +1,143 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "local": "reference/rank2/rank2.py", + "bytes": 8253, + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a", + "parent_local": "rank2.py" + }, + { + "local": "reference/rank2/SOURCES.json", + "bytes": 10337, + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641", + "parent_local": "SOURCES.json" + }, + { + "local": "reference/rank2/RECIPE.json", + "bytes": 4468, + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702", + "parent_local": "RECIPE.json" + }, + { + "local": "reference/rank2/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33", + "parent_local": "reference/linear/linear.py" + }, + { + "local": "reference/rank2/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "parent_local": "reference/linear/inputs/controller_reference.py" + }, + { + "local": "reference/rank2/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50", + "parent_local": "reference/linear/NOTICE.md" + }, + { + "local": "reference/rank2/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "parent_local": "reference/phase/phase.py" + }, + { + "local": "reference/rank2/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "parent_local": "reference/phase/inputs/controller_reference.py" + }, + { + "local": "reference/rank2/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0", + "parent_local": "reference/phase/NOTICE" + }, + { + "local": "reference/rank2/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744", + "parent_local": "reference/leaf/leaf.py" + }, + { + "local": "reference/rank2/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "parent_local": "reference/leaf/inputs/controller_reference.py" + }, + { + "local": "reference/rank2/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf", + "parent_local": "reference/leaf/NOTICE.md" + }, + { + "local": "reference/rank2/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "parent_local": "reference/source/clifford_exact.py" + }, + { + "local": "reference/rank2/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "parent_local": "reference/source/native_verify.py" + }, + { + "local": "reference/rank2/reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "parent_local": "reference/home/tape_graph.py" + }, + { + "local": "reference/rank2/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "parent_local": "machine.py" + }, + { + "local": "reference/rank2/reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099", + "parent_local": "reference/home/parent_adapter.py" + }, + { + "local": "reference/rank2/reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842", + "parent_local": "reference/home/NOTICE.md" + }, + { + "local": "machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "parent_local": "machine.py" + }, + { + "local": "reference/rank2/PROOF.md", + "bytes": 16634, + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352", + "parent_local": "PROOF.md", + "role": "frozen parent proof/manifest" + }, + { + "local": "reference/rank2/FREEZE.json", + "bytes": 5633, + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275", + "parent_local": "FREEZE.json", + "role": "frozen parent proof/manifest" + } + ], + "prior_proof": { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/current-coded-all-source-leaf/PROOF.md", + "blob": "5d619cfc2d3b7bc51e6fcc8e7a46ecd1e313e23d", + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d", + "local": "reference/pr6978-PROOF.md" + }, + "pr6978_head": "12e58dfdad9371a26f9978c814779da344fd80b4", + "parent_rank2_freeze_sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275" +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/adapter.py b/research/borrowed-header-data-only-home/implementation/inputs/core/adapter.py new file mode 100644 index 0000000000..8c1f0bed31 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/adapter.py @@ -0,0 +1,117 @@ +"""Paid Gamma6/HOME adapter for fixed-rank positive central join. + +Derived from the frozen rank2 adapter; Apache-2.0; Codex-assisted. +""" +from functools import cache +from hashlib import sha256 +import importlib.util +from pathlib import Path +import sys +import json + +HERE=Path(__file__).resolve().parent +sys.dont_write_bytecode=True +sys.pycache_prefix=str(HERE/'_unwritten_bytecode_cache') +if Path(sys.pycache_prefix).exists(): + raise ValueError('bytecode isolation path must remain absent') +import join as C +B1=HERE/'reference/rank2/reference/home/tape_graph.py' +D=C.load('positive_home_dispatch', B1) +CORE_BASE,GUIDE,TAPES=3,34,35 + + +@cache +def core(rank,mutation=None): + code,alphabet,_=C.compile_join(rank,mutation) + if alphabet!=('_','0','1','|'): + raise ValueError('changed fixed alphabet') + return code + + +def steps(g,tape,count,target): + for _ in range(abs(count)): + target=g.jump(target,((tape,1 if count>0 else -1),)) + return target + + +def copy_out(g,source,target,after): + state=g.state('repack') + g.add(state,after,tests=((source,'_'),)) + for bit in '01': + g.add(state,state,tests=((source,bit),),writes=((target,bit),(source,'_')), + moves=((source,1),(target,1))) + return state + + +def embed(g,code,after,rank): + labels=[g.state('POSITIVE_R'+str(rank)) for _ in code] + for pc,(op,*args) in enumerate(code): + state=labels[pc];g.rules.setdefault(state,[]) + nxt=labels[pc+1] if pc+1budget:raise ValueError('finite execution budget') + return state + + def _general(self,state,rules): + tapes=state.tapes;heads=state.heads;lows=state.lows;highs=state.highs;writes=state.writes + found=None + for rule in rules: + if all(tapes[t][heads[t]]==symbol for t,symbol in rule[0]): + if found is not None:raise ValueError('nondeterministic emitted table') + found=rule + if found is None:raise Rejected('literal scanned-symbol rejection') + for t,value in found[1]: + if heads[t]==state.origins[t] and value!=SYMBOLS['^']: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + for t,delta in found[2]: + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t] 0, 0<=rho=1 complex coefficients on one common quantum, with +h>=2 signed least-significant-first component bits and a delimiter after each +component. Each virtual symbol has the unchanged three-bit physical code: + + b=record_bits=6c(h+1), row_bits=2^a b, V=C_rows*2^a b. + +The complete V-bit public body and its frontier are preserved in format. +Signed width, coefficient order, quantum, row/outer labels and all spectator +coordinates stay fixed. Exact arithmetic and signed-prefix conditions are +retained below. + +For a fixed authenticated rank 1<=r<=8, construct a separate raw-binary view +that changes exactly + + child.f = r * parent.f. + +Every other one of the 22 values, including cutoff, stays unchanged. The +parent's complete bytes remain read-only and are returned to their origin. +This is a **LEAF-specific descriptor**. Its f has a different purpose from +the parent's native block count; it need not satisfy `(child.f-1)G<=H` or +`selected_axes=9*child.f+remainder`. No monomial, ordinary supplier, recursive +caller or general native adapter receives this view. Both monomials receive +the unchanged parent descriptor. + +The old positive leaf requires only positive outer,rows,f,K,cutoff, the +current record/row consistency, rho = i^p (-1)^(z dot a) |a xor x>. + +The checker independently propagates all 18 X_j/Z_j generators through both +circuits. An invertible binary permutation G sends (x,z,p) to +(Gx,G^(-T)z,p); translation b adds 2(z dot b) to p. For a diagonal phase +q(a)=sum alpha_j a_j+2 sum_(jj)Q_jk*x_k over GF(2). +For positive or negative C on mask v, a commuting Pauli stays fixed; an +anticommuting one has x replaced by x xor v and p increased by 3*sign modulo +four. These follow directly from the displayed normalized C matrix and +Pauli multiplication. A global i-phase cancels in conjugation. + +All primitive operators are unitary: permutations/translations are bijective, +diagonal entries have modulus one, and C^*C=I by its two exact coefficients. +The independent Gaussian elimination checks each needed binary inverse. + +**Separating-column lemma.** If two unitary matrices U,V have identical +conjugations of every X_j and Z_j, then U^*V commutes with these generators. +Commutation with every Z_j makes it diagonal in the computational basis; +commutation with every X_j makes all diagonal entries equal. Hence U^*V is +a scalar multiple of identity. Equality on one nonzero column fixes that +scalar to one. This proves equality on all 512 columns. + +The checker additionally evaluates the complete zero-input column of both +circuits using exact Gaussian integers and a power-of-two denominator. It +checks exact unit normalization, strips common factors of two, and compares +all 512 positions. Thus global phase is fixed, not identified projectively. +Across the complete family this gives 51,948 Pauli images and 1,477,632 +separating-column positions. Source-rank equality is independently checked +from the X parts of the images of Z generators. + +Two controls distinguish the lemma's premises. Changing the entrance's +constant phase preserves every Pauli image but changes the separating column. +Precomposing with input Z_0 preserves the zero-input column but changes a +Pauli image. A wrong middle rank is rejected too. Typed owner/rank/token +controls reject false source bindings. This is a finite exact check of the +fixed selected source family; the arbitrary-f conclusion follows from the +preceding coordinate/tensor argument and provider contracts. + +## 5. Literal metadata program, complete cost and historical backing + +The unchanged row Builder operates on physical alphabet 0/1, LEFT=2 and +BLANK=6. The descriptor is not a numeric CodedPort: its bits are already +physical bits. Roles 0..39 are fixed, with borrowed parent role 13, private +view role 14, and 38 other private roles. PREPARE consists only of local +read/write/unit-move, fixed goto and terminal states. Source authentication, +table construction and fixed cohort allocation are setup obligations, not +runtime shape oracles. There is no runtime conversion of f or E into host +integers and no input-dependent table expansion. + +After boundary/blank checks and canonical decoding of all 23 fields, +PREPARE multiplies the positive f body by the authenticated fixed r. Its +carry lies in 0..r-1. On input digit x and carry c it writes +`(r*x+c) mod 2` and changes c to `floor((r*x+c)/2)`. Induction on the +processed low digits proves the product; at most three fixed tail digits +remain for r<=8. The product is copied back to the f role and its scratch +is cleared. Canonical encoding then emits all 23 fields, after which every +decoded field is cleared. Only the view remains live at the returned origin. +These invariants prove correctness at every finite input bit length. + +Let n be the original f digit length, n' the product length, L the sum of +the 23 input lengths, and L' the output sum. Positivity gives + + n <= n' <= n+3, L' <= L+3, + E=2L+23, E'=2L'+23 <= E+6. + +The following conservative local-instruction bounds are inherited from the +literal Builder expansion proved in the published header-view package: + +| Primitive from stated origin/frontier | Instruction ceiling | +|---|---:| +| Rewind from n-digit frontier | 3n+5 | +| Rewind from origin | 5 | +| Clear n-digit body from origin | 7n+11 | +| Canonical check and origin return | 20n+20 | +| Copy n digits to blank role, return both origins | 11n+12 | +| Multiply positive n-digit body by fixed r<=8 | 31n+53 | +| Decode all 23 fields, return parent and retire guide | 27E+1064 | +| Encode all 23 fields of total physical length E' | 21E'+788 | + +The multiplication ceiling for fixed nine bounds our smaller carry/tail +graph as well. There are 159 initial boundary/blank-check instructions. +Adding decoding, the extra f check, multiplication, old-f clear, product +copy, product clear, encoding, all 23 final field clears and done gives + + 159+(27E+1064)+(20n+20)+(31n+53)+(7n+11) + +(11n'+12)+(7n'+11)+(21E'+788)+(7L'+253)+1 + <= 90E+2000. + +The numeric borrower returns the view head at origin. RELEASE clears all +39 roles and restores the parent, costing at most `7E'+435 <= 7E+477`. +The deliberately loose registered bound is therefore + + T_view <= 1000E+10000. + +Every counted physical read, write and unit move is an instruction; fixed +gotos are also included in the ceiling. This is a physical scan bound, +not a unit-price whole-header operation. Prepare graphs have 2607, 2619, +2633, 2647, 2663, 2679, 2695 and 2711 rows for ranks one through eight; +the shared release graph has 475 rows. + +During preparation all bodies are contiguous canonical digit prefixes and +the length guide. RELEASE erases the current live prefixes; it does not +search an old high-water mark. No interruption or foreign corrupted alphabet +is covered. The valid-format f=0 rejection is separately tested and safely +retired by the same mechanism. Successful numeric calls and named valid +numeric rejections return the view at its origin before RELEASE. + +At the numeric boundary this bank has just E' live view bits. A conservative +fresh-call peak is 5E+80 private body/frontier cells, plus supplied origins. +Across calls with M=max E, each of the 39 fixed roles visits at most 2M+1 +body/frontier cells. The retained bound is its supplied prefix backing plus +39(2M+1) and fixed program/setup storage. Different roles can reach their +maxima on different calls; the largest simultaneous live body does not bound +the retained backing. The original E-bit parent, numeric field and every +numeric work cohort remain separate charges. The sparse header checker +records all visited addresses, including reads and moves over blank cells. + +## 6. Whole invoices and relative MOVE contract + +Let F include fixed source authentication, catalog/record binding, finite +table construction and the charged creation of the fixed work banks. Let +T_C(V,h,w,E') be the complete unchanged positive-leaf bound, including +full-field ingress/egress, actual arithmetic, descriptor control, retirement +and source-specific fixed costs. The new positive child has + + T_child <= F + T_C(V,h,r*f,E') + 1000E+10000, + Q_child = 39+349 = 388 fixed private ports. + +The predecessor gives `T_C=O(w*V+(E'+1)^4+349)` on its admitted direct-leaf +domain, so this is `F+O(r*f*V+(E+1)^4+388)`. All transitive program constants +remain those of the actual source programs; this package does not extract a +new numerical all-input ceiling. In particular, it does not replace this +direct cost by an accelerated native tariff. There are no ordinary supplier +invocations in the standalone positive child. + +For the generic protected MOVE, let T_R and T_L be the complete right and +left monomial bills under the original parent descriptor, and let Q_R,Q_L +be their actual factory-dependent fixed port counts. The successful invoice +is + + F + T_R + T_C + T_L + T_view + 22V+35, + Q_MOVE = 1+Q_R+388+Q_L. + +For the documented q2/capacity64 ordinary factories the last expression is +4145, but it is not a universal constant across other factories. A named +valid returned failure replaces the administrative term by 13V+21 and +includes every executed provider action, failed scan and view cleanup. +These formulas include the original protected full-field stage. Child-local +rollback alone would not protect the original input after a successful +entrance; the whole-occurrence stage is essential. + +Space adds the stage body and its history, the new 39-role header bank, the +complete leaf and both complete monomial cohorts, the borrowed parent and +original field, caller ancestors, and fixed source/program storage. It sums +rolewise historical maxima even when cohorts have already been erased. The +monomial ordinary providers, their construction/cleanup, long-record access, +source placement and all inherited source-to-machine premises remain in this +relative MOVE theorem. The wrapper does not establish these services. + +## 7. Evidence, limitations and open questions + +The new source-family proof is finite and exact for the frozen selected +source, with no omitted charts. Its extension to all native column counts, +rows and spectators is the coordinate/tensor proof above, conditional on +the stated provider contracts and valid descriptor. It is not an inference +from random tests or a new proof of a general Clifford compiler. + +The physical header checker covers every rank one through eight, f in +{1,2,3,5,17}, a 1024-bit unused field, a separately labelled 257-bit f syntax +case, and long-then-short reuse. It checks every output byte and all 23 values, +parent preservation, translated ancestor prefixes, all visited private cells, +origin return and the instruction ceiling. Invalid rank, f=0 and unscaled-f +mutation controls reject. The large-f syntax case is not represented as an +admitted numerical parent. + +Completed full-packet numerical traces use every 4096 record in a valid +nine-coordinate parent with mandatory reservation bits and arbitrary tested +spectator patterns. Rank two and rank eight positive children return exact +independent Gaussian-character answers. The rank-two cutoff control has +parent f=1<=cutoff=1 but child width 2>1 and rejects. A final-pair parity +control also rejects, preserving the entire input and returning all headers +and work. The rank-eight fixture distinguishes individual axes by spectator +characters; it is not just a net phase-cancellation example. Numerical +primitive hardware is independently cross-checked against the unchanged +definitions; those finite checks alone are regression evidence, not a new +implementation theorem. + +These are complete child executions, not complete generic three-factor +MOVE executions. The predecessor's entrance/leaf-only partial evidence and +exit/whole timeouts remain labelled in that published package. This package +does not reclassify them or claim an uninterrupted full MOVE trace. + +The array hardware's role extents measure materialized backing, not every +visited blank address. Its saved receipts retain that label. A conservative +visited bound adds supplied initial regions and origins to the literal action +count: each unit move exposes at most one further address. The separate +source asymptotic space proof, and the sparse header tracker's actual visited +measure, are not inferred from those array extents. + +The immediate remaining obligations are: + +1. Join this rank-scaled positive child to a verified all-column monomial + construction with no ordinary numerical supplier premise, keeping the + complete cost and intermediate signed-phase domain. Serializing columns + can create a signed overflow that a cancelling batched phase avoids. +2. Bind actual enclosing caller placement, typed nested occurrences and + produced parent headers. A raw PAID/MOVE token is not a substituted + `source_ir.product` fragment. +3. Flatten the complete numeric adapters and protected control into literal + lifecycle tables with an independent equivalence proof. +4. Establish nonleaf supplier rates and global precision/stock/analytic + obligations for the full selected multiplication recurrence. + +This reduces one current `native_all_columns`/`precision_tape` interface to +an explicit direct-leaf construction. It discharges neither foundational +assumption in full. The selected multiplication bound remains conditional, +and there is no new kappa. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/FREEZE.json b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/FREEZE.json new file mode 100644 index 0000000000..f8b32e2611 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/FREEZE.json @@ -0,0 +1,179 @@ +{ + "schema": "literal-owned-rank2-freeze/1", + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "status": "author-frozen for independent review; no new scientific scope", + "core_graph": "6f440702d6d0b2428df1016f8006ae339699e8b9fe1cf9fe5dc0d2c111821adf", + "HOME_graph": "f2f957292847995587c2c269a19a72876e7f74a52f26b07f807eb50f09816e5f", + "files": [ + { + "path": "CHECKPOINT.md", + "bytes": 891, + "sha256": "096e7a8a1551ae6b9887ab5010a8f4026b6de78d97322c00a5380a0c9a72349c" + }, + { + "path": "ENVIRONMENT.json", + "bytes": 353, + "sha256": "41bebc6ecaf5e64b7d1075c62c30fead6efbd24e930933efa5095ad60554b660" + }, + { + "path": "GRAPH.json", + "bytes": 552, + "sha256": "d5b676671717a930bbc5796904e424f40a3aabbcaeebb61d84cdab6b4d30bd53" + }, + { + "path": "NOTICE.md", + "bytes": 3215, + "sha256": "8e4464c37453cede80b45ca5735a1aab22acd15d8796a78ba48713cc4717313a" + }, + { + "path": "OVERLAP.md", + "bytes": 2767, + "sha256": "43aeda8f27c34eafc18b2c93b25a8128eefed7cf7b152dd13eaf925a7cc8ac34" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 4206, + "sha256": "be862b0e585a1d74bb70369489358b21a0ec3ca06946977b839401a3bc6cef8b" + }, + { + "path": "PR-TITLE.txt", + "bytes": 73, + "sha256": "43e1c0e57941afc23d29d877488440eccfee1b4ec8a0c908ade46361543957a3" + }, + { + "path": "PROOF.md", + "bytes": 16634, + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352" + }, + { + "path": "README.md", + "bytes": 5822, + "sha256": "90d9ed2f26ade3fed562f7b930fd60fe56b75cef1b43cb2a24a0e99a52150210" + }, + { + "path": "RECIPE.json", + "bytes": 4468, + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + }, + { + "path": "REMOTE-BINDINGS.json", + "bytes": 967, + "sha256": "c3b16896601fc024e832ed7abb3266e16de170ed72a93f702a1a5e98e0f24694" + }, + { + "path": "RESULT.json", + "bytes": 5098, + "sha256": "1673bf5ca1d1d46762a67085e5dfc1d72d5e31a211bc2f56f8946efc6b07f127" + }, + { + "path": "SOURCE-BINDING.json", + "bytes": 515, + "sha256": "6eb220b27c95f6d104e1b51dfd79314905cb6dc84a81ca8d115b709d9416a945" + }, + { + "path": "SOURCES.json", + "bytes": 10337, + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641" + }, + { + "path": "adapter.py", + "bytes": 5777, + "sha256": "b0d60256c88ce106d3463a5f5b3cc6f7d1d11d3fad8f0fcb332bfcca3cdb1dcc" + }, + { + "path": "bind_source.py", + "bytes": 5125, + "sha256": "b4feddf21f9c693d8537218ed28c073d7a5d18e7d0cd9d35b0d9333e3386e76a" + }, + { + "path": "machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "oracle.py", + "bytes": 2460, + "sha256": "93c7964163fe0b9f7977703a78a456e81117d9d3f63e64ce213407a963c7b6ff" + }, + { + "path": "rank2.py", + "bytes": 8253, + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a" + }, + { + "path": "reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "path": "reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "path": "reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "path": "reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "path": "reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "path": "reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "path": "reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "path": "reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "path": "reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "path": "reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "verify.py", + "bytes": 12019, + "sha256": "c023806283adf2e1aec156b6a909a7620a0a6db70898baa0b3926a1f90a7cf83" + } + ] +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/PROOF.md b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/PROOF.md new file mode 100644 index 0000000000..627e54e031 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/PROOF.md @@ -0,0 +1,316 @@ +# Actual owned rank-two MOVE28141 on the complete Gamma6/HOME boundary + +## 1. Source, orientation and quantified statement + +Canonical main is e54523517d0f03e58352e647c403a5af3e525a57. The actual +selected #7000 record at zero-based index28141 is +`[MOVE,1526,601,470,true]`. Its complete frames are `[137]` and +`[75,137,265]` in nine coordinates. The Boolean marks owned/private +storage. The operator is determined by the ordered frame pair: + +`U=T_470 T_601^*`, `U=L (C_0 C_1) R`. + +Here `C=(1/2)[[1+i,1-i],[1-i,1+i]]` is positive. The rank is two. +No inverse orientation is inferred from the Boolean. The retained owned +recipe has the same pair but old role1421/event19592; these are not the +current event/owner. `bind_source.py --source-repo` authenticates the whole +350722-byte archive and canonical word, extracts current28141, reconstructs +the lowering and checks full signed Pauli action and exact Gaussian phase. +The independent engine's separating-column argument determines the entire +512-column operator. All1024 columns of the two binary maps are also checked. + +Supply positive f,r,P,S,cutoff and w>=2, the exact six positive canonical +Gamma codes `(f,r,P,S,w,cutoff)`, and the complete lexicographic packed array + +`[P] x [2^f]^9 x [S]`, `V=2PSr2^(9f)w`, `F=E+V`. + +E counts every header bit, including a potentially enormous cutoff code. +At each address there are r Gaussian coefficients, real then imaginary, +each signed w-bit MSB-first. Their common caller quantum Delta is unchanged. +r is coefficient multiplicity. The native rank two changes neither r nor +the nine f-bit slots. The direct entry condition is **2f<=cutoff**. + +Require the right and left phase rotations to fit signed w bits, and every +output of each of the actual2f central C axes to be Gaussian-integral on +the same grid and fit signed w bits. Final fit alone does not supply these +prefix conditions. All complete spectators and coefficient fields remain. +The native local boundary supplies distinct owners, heads at their origins, +blank required private windows/guards and preserved opaque exteriors, as in +the retained factors. Existing historical backing remains charged. + +**Theorem.** One fixed115776-location,31-tape four-symbol local program +returns `U^(tensor f)` on the original DATA owner, restores HEADER, all heads, +private bodies/guards and opaque exteriors, under these promises. It checks +2f against the actual cutoff. A valid-format cutoff or numerical rejection +precedes every original DATA write; failure cleanup/retry is unclaimed. +Its complete successful direct bounds are + +`T_core<=2^24(fV+E+1)`, +`K_final<=K_entry+1024(V+E+1)`. + +The supplied packed HOME adapter emits115953 states on35 fixed tapes. It +returns the identical Gamma6 header and transformed DATA to the same owned +HOME1526, with + +`T_HOME<=128(F+1)+2^24(fV+E+1)`, +`K_final<=K_entry+1088(F+1)`. + +B1's general full-bank gathering/return is separately charged at its +`O(R K(F+1))` invoice. The test graph uses an already-reserved typed owned +entry. It constructs neither INIT1526 nor a complete enclosing caller. + +## 2. Exact nontrivial factors and all-column geometry + +The complete matrices, alpha/Q fields and80 retained records are in +RECIPE.json. In the source convention a monomial sends +`|x> -> i^q(x) |Gx>`; both offsets and constant phases are zero. The rows are + +``` +G_R=(258,11,321,66,4,328,16,32,128), +G_L=(6,11,16,34,64,128,3,256,1). +``` + +Its right phase is + +`q_R=x0+2x1+x3+2x6` +` +2(x0x1+x0x3+x0x6+x0x8+x1x3+x1x6+x1x8+x3x6+x3x8) mod4`. + +Its left phase is `q_L=2x0+3x1 mod4`. Q's diagonal is already encoded in +alpha and is not added twice. The left36 records consist of five S records +and31 CNOTs. The right44 consist of six S, nine CZ and29 CNOTs. The literal +phase compiler handles each complete phase in one body pass, retaining the +actual simultaneous residue and signed range guards. It does not serially +negate an intermediate component just to realize that record list. + +For columns x_j the phase is `sum_j q(x_j)` (the constant term is zero). +Each binary row addition acts on the matching bit j in its two complete +f-bit slots. The retained CNOT routine derives every prefix/middle/suffix +length from the original header and executes all f columns. Fixed word +order is preserved. The generic fixed-word emitter in rank2.py changes +only which fixed source CNOTs call that unchanged routine. Its proof applies +to any distinct fixed slot pair in0..8; no runtime matrix loader is used. + +Let S01 exchange slots0 and1 through the fixed CNOT word +`(0<-0 xor1),(1<-1 xor0),(0<-0 xor1)`. It is an exact permutation with no +phase. The chronological factor list is + +| Order | Literal component | +|---:|---| +|1|Rank-aware entry guard, original header retained| +|2|Right complete phase| +|3|Right29-CNOT binary map| +|4|Unchanged positive first-slot C leaf on all f axes| +|5|S01, three CNOTs on every column| +|6|Unchanged positive first-slot C leaf again| +|7|S01 again| +|8|Left complete phase| +|9|Left31-CNOT binary map| + +Because S01 C0 S01=C1 and the two disjoint C blocks commute, the central +time sequence C0,S01,C0,S01 is exactly `C0 C1`. This retains all9f address +bits and implements the desired positive `C^(tensor2f)` on the first two +slots. Setting the existing leaf header's f to2f would instead change its +hard-coded nine-slot volume to2^(18f); that is not this construction. + +The independent source engine checks the exact interleaved central circuit, +including its phase, against C0 C1. Tensoring this fixed product proves the +all-f result, including arbitrary full spectators and r coefficients. No +tensor power is distributed over a sum or scalar ADD. + +## 3. Literal rank-aware entry and complete transaction + +The new guard uses the retained Gamma/unary/binary comparison routines on +their same29 ports. It decodes f and captures its canonical binary digits +and length. It appends one physical zero to the captured binary word and +one mark to its length. These are exactly the digits/length of2f. The +original unary F guide and public header are unchanged. It decodes the other +four bounded integers, reads cutoff only in binary, compares length then +lexicographic digits, and returns/clears its complete work. It never loops +over the numerical cutoff. Thus f<=cutoff<2f rejects even though both +unchanged single-slot leaves would individually accept. + +The whole core clones original DATA once onto WORK and uses TRACE to return +the original head. Every factor's public DATA port is WORK, its HEADER port +is original HEADER, and private port t>=2 maps to t+2. WORK and TRACE are +distinct from all reused module-private owners. The maximum module port28 +maps to30, so ports0..30 suffice. Each retained instruction's port and PC +are relocated; its successful halt is a one-step goto continuation. No +runtime callback, scalar oracle, size-specialized table or free return +implements a component. + +Every completed factor returns all its heads and clears its private work. +Consequently the same27 module-private tapes can be reused by the next +factor. An intermediate public commit of a retained module changes only +WORK. The original DATA receives no write until all nine components have +returned. The single final V-bit copy installs the complete result on the +same original owner, records its return trace, erases WORK and disposes +WORK/TRACE guards. No owner is replaced, relabelled or given productive credit. + +Rejection may leave private data/heads dirty. The core has no original-DATA +WRITE before its final commit location115742. The HOME adapter similarly +keeps all core activity private and scatters only after complete successful +return. This proves original public preservation on the stated finite +cutoff/numerical failures, including failure in the second C pass after a +completed first C and swap. It does not prove interruption rollback or retry. + +## 4. Exact numerical domain and sufficient reserve + +The retained leaf uses actual w+2-bit signed temporary numerators and exact +parity/range guards. Its four real rows have three plus signs and one minus, +so their actual values lie within the proved w+2 range for signed w-bit +inputs. Each retained phase rejects a requested negation of the unique +most-negative component. Copying or swapping that component without +negation is permitted. These concrete conditions, not an abstract fused +Gaussian primitive, are the numerical premises in section1. + +A useful sufficient caller condition is: all original components are +divisible by2^f, bounded in absolute value by M, and + +`2^f M <= 2^(w-1)-1`. + +The credited denominator/component-norm facts for a j-axis C prefix give +denominator dividing2^ceil(j/2) and component maximum norm2^ceil(j/2). +For j<=2f, both exponents are at most f. R preserves divisibility and +component magnitude, so every actual central prefix is integral and +symmetric-range bounded; permutations and L's unit phase remain safe. +This is a sufficient reserve, not a necessary domain or new norm theorem. + +No scale, width converter or rounding is installed. The original common +quantum, w and all header bits return unchanged. The selected application +review's common grid p+D and width p+h+2D+3 provide a conditional semantic +route, but this module does not emit its actual parameter/header producer +or assert that it supplies the sufficient divisibility condition above. +A caller may instead prove the precise correlated-prefix premises. + +## 5. Complete time and historical backing + +Every local read, write, unit move, goto and halt costs one step. All scans, +descriptor production, source copies, arithmetic, component seeks, history +returns and retirement below are included. Source helper prices are exact: +rewind3n+3, unary clear7n+4, unary copy +`(6+5t+z)n+5e+7`, doubling47n+18. Gamma prefix values sum to less than the +decoded value. Set Z=f+r+P+S+w<=5V. + +For the rank guard, five conversions including their trace/capture work +fit256(E+Z+1), the appended binary/length marks fit32(E+1), binary cutoff +decoding and the length/lexicographic comparison fit128(E+1), and all +remaining guide/guard returns and erasure fit128(E+Z+1). These follow by +the displayed helper prices and constant-depth prefix/tail loops; every +extra retained binary track is at most E+1. The larger envelope +`1024(E+Z+1)<=6144(V+E+1)` therefore covers the guard. Reserve +`65536(V+E+1)` to simplify the aggregate. + +The unchanged per-CNOT geometry/pass/retirement proof gives a bound for any +fixed k-gate nine-slot word: + +`T_G(k)<=1024 k f(V+1)+8192(V+E+1)`. + +The per-gate price does not depend on the old selected19/27-word counts. +The new four words have k=29,3,3,31, for a total66 CNOTs. Their shapes, +geometry construction, complete clone/commit and cleanup are all paid. +The other credited complete bounds are + +* two first-slot leaves: each65536(fV+E+1); +* each m=9 phase: at most65536(E+65V+1); +* outer whole-call transaction: exactly31V+27. + +Their sum, with f(V+1)<=2fV and V<=fV, is at most + +`8884255 fV +360448 E +360475 <=2^24(fV+E+1)`. + +This counts both active C blocks and every helper; no separately unpaid +recursive child is hidden in the bill. It is a direct-leaf rate. At a fixed +admitted active-axis cutoff q,2f<=q makes it O_q(F+1). Encoded cutoff value +and E are not made constants by that statement. No faster nonleaf tariff, +global kappa or complete selected dispatcher follows. + +For historical backing, the guard visits at most6V+7E+57 additional cells: +five decoded unary guides, DOUBLE, header trace/length, binary words and +lengths, all guard/end cells and public header positions. This is below +64(V+E+1). Each fixed binary word and each C leaf has credited complete +increment64(V+E+1), independent of its fixed word length. Each phase fits +256(V+E+1). The outer WORK/TRACE transaction adds8(V+E+1). Adding rather +than refunding successive increments gives + +`(64+4*64+2*64+2*256+8)(V+E+1)=968(V+E+1)<1024(V+E+1)`. + +K_entry includes every owner's complete earlier/opaque backing. At fixed +origins shorter successful calls scan only current live bodies and reuse +already blank tails, while earlier visited maxima remain. Changed origins +require actual interval unions and separately paid corridors; erasure or +new virtual names do not refund backing. + +## 6. Supplied owned HOME and following scalar contacts + +The retained B1 adapter copies/splits exactly six Gamma codes and complete +DATA onto private native HEADER/DATA. Its native origins are B-relative2, +leaving guard cell1 blank and preserving permanent B origin marker^ at0. +Core ports map injectively to3..33 and the header-length guide uses34. +Thus35 fixed tapes suffice. A larger consumer may reuse these after return; +the rank2 service does not allocate one tape per column or coefficient. + +On successful core return, it copies HEADER then DATA back to the complete +operand, erases copies and restores all heads/guards to B origins. The +unchanged scan/count proof gives adapter time128(F+1) and increment64(F+1). +B1 scatters exactly F bits to the same immutable HOME. Its general +full-bank delivery/return remains O(R K(F+1)); one local adapter is not an +unpriced complete source caller. The test's two homes contain one parked +productive input and the supplied live owned1526 packet. Entry is +graph.execution_start, after reservation, and productive_count=1 is fixture +bookkeeping. Owned1526 receives no productive credit or typed INIT here. + +Because the operation returns the exact original header, w/grid, geometry +and F, the existing signed HOME ADD can consume1526 after this return if +receiver1515 is supplied in frame470 with the identical header/common grid. +Frame/grid equality is a typed premise, not inferred from header bits. +That ADD preserves source1526 and costs4096(F+1), with increment8(F+2). +The four exterior SUBs at28041/28129/28135/28139 require matching frame601 +packets beforehand. Their coefficients stay-1 for every f; they are not +tensor-powered scalar signs. The ADD at28159 stays+1. + +For just these five arithmetic contacts and one MOVE, a conservative +standalone primitive bill is + +`20608(F+1)+2^24(fV+E+1)`, + +plus actual B1 delivery/reservation and all source/receiver production. +This is a boundary compatibility/ledger, not a six-event execution or the +full9582-event interval. INIT28037, receiver INIT28153, subsequent-1/4 SCALE, +dirty CLEAR37618, all intervening events and their producers remain separate. +No zero-at-CLEAR or free release theorem is asserted. + +## 7. Evidence, overlap and limits + +The full actual m=9,f=1 dense Gaussian packet returns on its owned HOME in +25854536 transitions, with5132 HOME writes only after complete primitive +return. A smaller nonzero packet reuses the same owners in20881778 steps +and retains the larger previous guide history. A wrong full-graph constant +phase returns exactly i times the expected image, so the oracle separates +the actual absolute phase. All35 heads, bodies/guards and opaque exteriors +return on successful cases. The forward oracle uses the original two frame +circuits and complete numerator accumulation, not the emitted factor word. + +The cutoff rejection f=1,cutoff=1 takes118370 transitions with no HOME write. +A source-constructed numerical case completes first C plus slot swap after +12601857 steps, has its complete intermediate WORK checked, then rejects +the second C at12803606 steps, again with no HOME write. Its failure cleanup +is deliberately unclaimed. Twenty-six guard-only header cases reach f129 +and4097-bit cutoff syntax at distinct signed origins; those are not full +f2/f129 DATA executions. Actual changed retained bytes, wrong source phase, +inverse quotient and a one-C substitute are rejected/separated. + +Source-complete positive rank-two leaves and their rank-scaled23-value +descriptor/cutoff already exist in #6978. Its protected whole MOVE retains +the two monomial/ordinary-provider premises and explicitly leaves their +supplier-free/literal join open. The present object is this actual owned +601→470 fixed-table join and unchanged Gamma6/HOME packet, not new C tensor +algebra, new rank-two factorization or first rank-two leaf. The prior selected +rank1 join, phase/G/leaf tables and HOME adapter retain their credit. Related +rank-two clean scalar conjugators/Pauli fusion macros do not supply these +complete stream tables. Bounded searches and exact pins are in OVERLAP.md. + +No endpoint scaling, full lifetime, format producer, arbitrary malformed +packet guarantee, rejection reuse, materialized uniform source word or +nonleaf supplier is supplied. All five selected assumptions and +kappa=.00363005817 remain. This is an AI-authored proof and finite replay, +not human or formal-kernel acceptance. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/RECIPE.json b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/RECIPE.json new file mode 100644 index 0000000000..04f5dc8367 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/RECIPE.json @@ -0,0 +1,490 @@ +{ + "source_event_index": 28141, + "source_event": [ + "MOVE", + 1526, + 601, + 470, + true + ], + "frames": { + "601": [ + 137 + ], + "470": [ + 75, + 137, + 265 + ] + }, + "retained_event": 19592, + "retained_role": 1421, + "rank": 2, + "left": { + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 11, + 16, + 34, + 64, + 128, + 3, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "right": { + "linear_Z4": [ + 1, + 2, + 0, + 1, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 258, + 11, + 321, + 66, + 4, + 328, + 16, + 32, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 331, + 329, + 0, + 331, + 0, + 0, + 11, + 0, + 11 + ] + }, + "left_records": [ + [ + "S", + 0 + ], + [ + "S", + 0 + ], + [ + "S", + 1 + ], + [ + "S", + 1 + ], + [ + "S", + 1 + ], + [ + "XROW", + 7, + 8 + ], + [ + "XROW", + 8, + 7 + ], + [ + "XROW", + 7, + 8 + ], + [ + "XROW", + 2, + 5 + ], + [ + "XROW", + 1, + 5 + ], + [ + "XROW", + 0, + 5 + ], + [ + "XROW", + 5, + 8 + ], + [ + "XROW", + 8, + 5 + ], + [ + "XROW", + 5, + 8 + ], + [ + "XROW", + 4, + 6 + ], + [ + "XROW", + 6, + 4 + ], + [ + "XROW", + 4, + 6 + ], + [ + "XROW", + 8, + 3 + ], + [ + "XROW", + 0, + 3 + ], + [ + "XROW", + 3, + 6 + ], + [ + "XROW", + 6, + 3 + ], + [ + "XROW", + 3, + 6 + ], + [ + "XROW", + 8, + 2 + ], + [ + "XROW", + 1, + 2 + ], + [ + "XROW", + 0, + 2 + ], + [ + "XROW", + 2, + 3 + ], + [ + "XROW", + 3, + 2 + ], + [ + "XROW", + 2, + 3 + ], + [ + "XROW", + 8, + 1 + ], + [ + "XROW", + 3, + 1 + ], + [ + "XROW", + 0, + 1 + ], + [ + "XROW", + 8, + 0 + ], + [ + "XROW", + 6, + 0 + ], + [ + "XROW", + 0, + 1 + ], + [ + "XROW", + 1, + 0 + ], + [ + "XROW", + 0, + 1 + ] + ], + "right_records": [ + [ + "S", + 0 + ], + [ + "S", + 1 + ], + [ + "S", + 1 + ], + [ + "S", + 3 + ], + [ + "S", + 6 + ], + [ + "S", + 6 + ], + [ + "CZ", + 0, + 1 + ], + [ + "CZ", + 0, + 3 + ], + [ + "CZ", + 0, + 6 + ], + [ + "CZ", + 0, + 8 + ], + [ + "CZ", + 1, + 3 + ], + [ + "CZ", + 1, + 6 + ], + [ + "CZ", + 1, + 8 + ], + [ + "CZ", + 3, + 6 + ], + [ + "CZ", + 3, + 8 + ], + [ + "XROW", + 6, + 8 + ], + [ + "XROW", + 3, + 8 + ], + [ + "XROW", + 1, + 8 + ], + [ + "XROW", + 7, + 8 + ], + [ + "XROW", + 8, + 7 + ], + [ + "XROW", + 7, + 8 + ], + [ + "XROW", + 3, + 6 + ], + [ + "XROW", + 0, + 6 + ], + [ + "XROW", + 5, + 7 + ], + [ + "XROW", + 7, + 5 + ], + [ + "XROW", + 5, + 7 + ], + [ + "XROW", + 4, + 6 + ], + [ + "XROW", + 6, + 4 + ], + [ + "XROW", + 4, + 6 + ], + [ + "XROW", + 5, + 3 + ], + [ + "XROW", + 0, + 3 + ], + [ + "XROW", + 3, + 4 + ], + [ + "XROW", + 4, + 3 + ], + [ + "XROW", + 3, + 4 + ], + [ + "XROW", + 2, + 4 + ], + [ + "XROW", + 4, + 2 + ], + [ + "XROW", + 2, + 4 + ], + [ + "XROW", + 3, + 1 + ], + [ + "XROW", + 2, + 1 + ], + [ + "XROW", + 0, + 1 + ], + [ + "XROW", + 2, + 0 + ], + [ + "XROW", + 0, + 1 + ], + [ + "XROW", + 1, + 0 + ], + [ + "XROW", + 0, + 1 + ] + ] +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/SOURCES.json b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/SOURCES.json new file mode 100644 index 0000000000..0ea6091131 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/SOURCES.json @@ -0,0 +1,232 @@ +{ + "schema": "literal-rank2-source-pins/1", + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "39b40c465f7636a4bb6d70af28595fe8f70f4f3f", + "path": "research/literal-selected-linear-maps/linear.py", + "local": "reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33", + "blob": "6aad40a6c47ed4415917c86fabbd5227a3819a41" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "39b40c465f7636a4bb6d70af28595fe8f70f4f3f", + "path": "research/literal-selected-linear-maps/inputs/controller_reference.py", + "local": "reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "39b40c465f7636a4bb6d70af28595fe8f70f4f3f", + "path": "research/literal-selected-linear-maps/NOTICE.md", + "local": "reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50", + "blob": "3a3030f23df347c1e45ddf92d2083f89ed16cc67" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/phase.py", + "local": "reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "blob": "d48978145821fc4a62d534bef2bef9449bda883a" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/inputs/controller_reference.py", + "local": "reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/NOTICE", + "local": "reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0", + "blob": "7a1f1da9c59d40b1e72905fee5344a8db9ca4353" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "path": "research/literal-positive-c-leaf/leaf.py", + "local": "reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744", + "blob": "bdcc80cbd8b64c601e6d69b7d25ece444b8b1ae2" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "path": "research/literal-positive-c-leaf/inputs/controller_reference.py", + "local": "reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "path": "research/literal-positive-c-leaf/NOTICE.md", + "local": "reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf", + "blob": "71c5f6dae2c799ce5d76c544e98d1ee7c52ef76c" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/reference/clifford_exact.py", + "local": "reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/reference/native_verify.py", + "local": "reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/tape_graph.py", + "local": "reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "blob": "f307133f2b0bba2e5969825cb814503d819322e7" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "13c29e2df66ba46402d4da5f1d2489ebf333e5fe", + "path": "research/source-bound-move-home-primitive/machine.py", + "local": "machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "13c29e2df66ba46402d4da5f1d2489ebf333e5fe", + "path": "research/source-bound-move-home-primitive/adapter.py", + "local": "reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099", + "blob": "10606f87dcfa0781bcae900d95cb86925961d453" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "13c29e2df66ba46402d4da5f1d2489ebf333e5fe", + "path": "research/source-bound-move-home-primitive/NOTICE.md", + "local": "reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842", + "blob": "db83fd95e175c90a2f9e51545b4be4557fbb919e" + } + ], + "generated": [ + { + "local": "RECIPE.json", + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + } + ], + "upstream_artifacts": [ + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/reference/selected-native.json.gz", + "bytes": 350722, + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "blob": "74563a7867d9d762b6588f65362369668841bb3e", + "canonical_sha256": "91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097" + } + ], + "proof_inputs": [ + { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/owned-ascent-contract/RECIPES.json", + "bytes": 126616, + "sha256": "d6753d91211e7c919519835b1e3da04bb165674ab3c93cd74e4768ca0c7e444f", + "blob": "bde1249d259e8633c9a5eb6afceae12bfb3cd351", + "role": "exact retained36/44 record recipe and older identity" + }, + { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/owned-ascent-contract/PROOF.md", + "bytes": 17222, + "sha256": "6479ac35c78a773adde421fdb1127472554c7687f038c4516d5ae8a962f4120d", + "blob": "32ff104fa88f7968ac5f66f804f28565bfcd84aa", + "role": "owned quotient/lifetime and dirty-return scope" + }, + { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/owned-ascent-contract/verify.py", + "bytes": 12434, + "sha256": "748bcd3a4d78002ff065c67872650bf9bfae8f0ab87fef8af2bfda4d4a31d2e6", + "blob": "b3683d81a1b4b6f7468cf3cb52f6144375d3377f", + "role": "ownership flag source semantics" + }, + { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "bytes": 25533, + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "role": "current exact common grid, full factor and exterior scalar contract" + }, + { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/current-coded-all-source-leaf/PROOF.md", + "bytes": 20312, + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d", + "blob": "5d619cfc2d3b7bc51e6fcc8e7a46ecd1e313e23d", + "role": "prior source-complete rank-two coded child and open supplier-free/literal join" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "39b40c465f7636a4bb6d70af28595fe8f70f4f3f", + "path": "research/literal-selected-linear-maps/PROOF.md", + "bytes": 17153, + "sha256": "217b6bbe9271aa5d5c0f0999a231d7386c7ba3fc432a88e3796d70ca283eb322", + "blob": "38f9adc04e3fb87d43dd92cfd3bd667a65d04238", + "role": "generic fixed CNOT geometry, per-gate cost and backing" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/PROOF.md", + "bytes": 17878, + "sha256": "55f0a575f618bf467d0e25a25802053455d701cee1f23fb8811a671a1bd59ff3", + "blob": "46a43bf214d828aa972db66ad35e41b9cd07a964", + "role": "generic fixed m9 phase and complete cost/backing" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "path": "research/literal-positive-c-leaf/PROOF.md", + "bytes": 16608, + "sha256": "c99157c3c43ae490b858cdbce04d85f3661ca5d9752770506d18ec4876c4ed6c", + "blob": "a8ae6684d55e3a1aaa7f2aa432f15ae9db580b11", + "role": "first-slot C exact numerator/prefix/cutoff/cost/backing" + } + ] +} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/machine.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/machine.py new file mode 100644 index 0000000000..fcd4ac01f0 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/machine.py @@ -0,0 +1,129 @@ +"""Dense interpreter of literal Graphs; observers never drive control. Apache-2.0.""" +from dataclasses import dataclass +SYMBOLS={s:i for i,s in enumerate('_01^|$')} + + +class Rejected(ValueError):pass +class MonitorViolation(ValueError):pass + + +@dataclass +class State: + tapes:list + heads:list + origins:list + lows:list + highs:list + entry_lows:list + entry_highs:list + writes:list + steps:int=0 + + def clone(self): + return State([bytearray(t) for t in self.tapes],self.heads.copy(),self.origins.copy(), + self.lows.copy(),self.highs.copy(),self.entry_lows.copy(),self.entry_highs.copy(), + self.writes.copy(),self.steps) + + +def initial(payloads,tape_count,*,old_history=0): + if len(payloads)!=2 or len(payloads[0])!=len(payloads[1]) or not payloads[0]: + raise ValueError('two complete same-F source homes') + f=len(payloads[0]);capacity=16*(f+128)+256 + origins=[17+(t%7) for t in range(tape_count)] + text='^'+'|'.join(payloads)+'|$' + tapes=[bytearray(capacity) for _ in range(tape_count)] + for tape,o in zip(tapes,origins): + tape[o]=SYMBOLS['^'];tape[o-3:o]=bytes([2,1,4]);tape[-3:]=bytes([1,4,2]) + o=origins[0];tapes[0][o:o+len(text)]=bytes(SYMBOLS[s] for s in text) + lows=origins.copy();highs=origins.copy();highs[0]=o+len(text)-1 + if old_history:highs[-1]=origins[-1]+old_history + return State(tapes,origins.copy(),origins,lows.copy(),highs.copy(),lows,highs,[0]*tape_count) + + +class Program: + def __init__(self,graph): + names=list(graph.rules);self.labels={name:i for i,name in enumerate(names)} + self.labels['HALT']=-1;self.start=self.labels[graph.start];self.rows=[] + for name in names: + rules=[(tuple((t,SYMBOLS[s]) for t,s in r.tests), + tuple((t,SYMBOLS[s]) for t,s in r.writes),r.moves, + self.labels[r.target]) for r in graph.rules[name]] + if rules and all(len(r[0])==1 and not r[1] and not r[2] for r in rules) and len({r[0][0][0] for r in rules})==1: + branch=[-2]*6 + for r in rules:branch[r[0][0][1]]=r[3] + self.rows.append((0,rules[0][0][0][0],branch)) + elif len(rules)==1 and not rules[0][0]: + _,writes,moves,nxt=rules[0] + if len(writes)==1 and not moves:self.rows.append((1,writes[0][0],(writes[0][1],nxt))) + elif len(moves)==1 and not writes:self.rows.append((2,moves[0][0],(moves[0][1],nxt))) + elif not moves and not writes:self.rows.append((3,nxt,None)) + else:self.rows.append((4,rules,None)) + else:self.rows.append((4,rules,None)) + + def run(self,state,*,start=None,stop=None,budget=100000000): + pc=self.start if start is None else self.labels[start] + stop_pc=None if stop is None else self.labels[stop] + rows=self.rows;tapes=state.tapes;heads=state.heads + lows=state.lows;highs=state.highs;writes=state.writes + while pc!=-1 and pc!=stop_pc: + op,t,arg=rows[pc] + if op==0: + pc=arg[tapes[t][heads[t]]] + if pc==-2:raise Rejected('literal scanned-symbol rejection') + elif op==1: + value,pc=arg + if heads[t]==state.origins[t] and value!=3: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + elif op==2: + delta,pc=arg + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t]budget:raise ValueError('finite execution budget') + return state + + def _general(self,state,rules): + tapes=state.tapes;heads=state.heads;lows=state.lows;highs=state.highs;writes=state.writes + found=None + for rule in rules: + if all(tapes[t][heads[t]]==symbol for t,symbol in rule[0]): + if found is not None:raise ValueError('nondeterministic emitted table') + found=rule + if found is None:raise Rejected('literal scanned-symbol rejection') + for t,value in found[1]: + if heads[t]==state.origins[t] and value!=SYMBOLS['^']: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + for t,delta in found[2]: + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t]0 else -1),)) + return target + + +def copy_out(g,source,target,after): + state=g.state('repack') + g.add(state,after,tests=((source,'_'),)) + for bit in '01': + g.add(state,state,tests=((source,bit),),writes=((target,bit),(source,'_')), + moves=((source,1),(target,1))) + return state + + +def embed(g,code,after): + labels=[g.state('MOVE24472') for _ in code] + for pc,(op,*args) in enumerate(code): + state=labels[pc];g.rules.setdefault(state,[]) + nxt=labels[pc+1] if pc+1= len(self.cells): + self.cells.extend('_' for _ in range(self.head+1-len(self.cells))) + self.cells[self.head] = value + self.peak = max(self.peak, len(self.cells)) + + def move(self, delta): + if delta not in (-1,0,1): + raise ValueError('one physical transition moves at most one cell') + if self.head+delta < 0: + raise ValueError('head crossed permanent origin') + self.head += delta + self.visited.add(self.head) + self.peak = max(self.peak,self.head+1) + + def contents(self): + return ''.join(self.cells) + + +@dataclass(frozen=True) +class Rule: + tests: tuple + writes: tuple + moves: tuple + target: str + + +class Graph: + def __init__(self): + self.rules = {} + self.serial = 0 + self.start = None + self.execution_start = None + self.checkpoints = {} + + def state(self, stem): + result = f'{stem}.{self.serial}' + self.serial += 1 + return result + + def add(self, state, target, tests=(), writes=(), moves=()): + self.rules.setdefault(state, []).append(Rule(tuple(tests), tuple(writes), + tuple(moves), target)) + + def jump(self, target, moves=()): + state = self.state('jump') + self.add(state, target, moves=moves) + return state + + def rewind(self, tape, target, erase=False): + state = self.state('erase' if erase else 'rewind') + self.add(state, target, tests=((tape, '^'),)) + for symbol in ALPHABET.replace('^', ''): + self.add(state, state, tests=((tape, symbol),), + writes=((tape, '_'),) if erase else (), moves=((tape, -1),)) + return state + + def validate(self): + # Exact symbolic determinism: two patterns overlap iff every shared + # tested tape has the same symbol. No wildcard expansion is needed. + for state, rules in self.rules.items(): + for i, a in enumerate(rules): + if a.target not in self.rules and a.target != 'HALT': + raise ValueError('undefined graph continuation') + for b in rules[:i]: + left, right = dict(a.tests), dict(b.tests) + if all(left[t] == right[t] for t in left.keys() & right.keys()): + raise ValueError('nondeterministic graph state '+state) + + def run(self, tapes, limit=10000000, checkpoint=None, start=None): + state, steps = self.start if start is None else start, 0 + while state != 'HALT': + if checkpoint and state in self.checkpoints: + checkpoint(self.checkpoints[state], tapes) + if steps >= limit: + raise ValueError('literal graph execution capacity') + matches = [r for r in self.rules[state] + if all(tapes[t].read() == value for t, value in r.tests)] + if len(matches) != 1: + raise ValueError('malformed tape or nondeterministic transition '+state) + rule, = matches + for tape, value in rule.writes: + tapes[tape].write(value) + for tape, delta in rule.moves: + tapes[tape].move(delta) + state, steps = rule.target, steps+1 + if checkpoint and 'HALT' in self.checkpoints: + checkpoint(self.checkpoints['HALT'], tapes) + return steps + + +def service(graph, name, arity, target): + """Four small supplied primitive graphs used ONLY by finite fixtures. + + Real scientific scalar/route/leaf graphs are still premises of the theorem. + Tapes 1,2 are operands; tape 3 is retained private primitive scratch. + """ + if name == 'REV': + if arity != 1: + raise ValueError('unary reversal') + cleanup = graph.rewind(3, target, erase=True) + back_operand = graph.rewind(1, cleanup) + copy = graph.state('reverse-install') + graph.add(copy, back_operand, tests=((3, '|'),), writes=((1, '|'),)) + for bit in '01': + graph.add(copy, copy, tests=((3, bit),), writes=((1, bit),), + moves=((1, 1), (3, 1))) + install = graph.jump(copy, ((1, 1), (3, 1))) + rewind_scratch = graph.rewind(3, install) + reverse = graph.state('reverse-copy') + graph.add(reverse, rewind_scratch, tests=((1, '^'),), writes=((3, '|'),)) + for bit in '01': + graph.add(reverse, reverse, tests=((1, bit),), writes=((3, bit),), + moves=((1, -1), (3, 1))) + begin_reverse = graph.jump(reverse, ((1, -1), (3, 1))) + seek = graph.state('reverse-seek') + graph.add(seek, begin_reverse, tests=((1, '|'),)) + for bit in '01': + graph.add(seek, seek, tests=((1, bit),), moves=((1, 1),)) + return graph.jump(seek, ((1, 1),)) + if name == 'FIRST': + if arity != 1: + raise ValueError('unary leaf fixture') + at = graph.state('first-bit') + for bit in '01': + graph.add(at, target, tests=((1, bit),), writes=((1, str(1-int(bit))),), + moves=((1, -1),)) + return graph.jump(at, ((1, 1),)) + if name not in ('ZERO', 'NOT', 'XOR') or arity != (2 if name == 'XOR' else 1): + raise ValueError('missing supplied primitive graph') + cleanup = target + for tape in range(arity, 0, -1): + cleanup = graph.rewind(tape, cleanup) + loop = graph.state('primitive-'+name) + graph.add(loop, cleanup, tests=tuple((t, '|') for t in range(1, arity+1))) + if name == 'XOR': + for a in '01': + for b in '01': + graph.add(loop, loop, tests=((1, a), (2, b)), + writes=((2, str(int(a)^int(b))),), moves=((1, 1), (2, 1))) + else: + for bit in '01': + graph.add(loop, loop, tests=((1, bit),), + writes=((1, '0' if name == 'ZERO' else str(1-int(bit))),), + moves=((1, 1),)) + return graph.jump(loop, tuple((t, 1) for t in range(1, arity+1))) + + +def scan(graph, homes, selected, gather, target): + """Unroll finite home order; scan arbitrary F only by field delimiters.""" + next_state = graph.rewind(0, target) + for home in range(homes-1, -1, -1): + work = selected.get(home) + after = next_state + loop = graph.state('gather' if gather else 'return') + if work: + graph.add(loop, after, tests=((0, '|'),) if gather else ((0, '|'), (work, '|')), + writes=((work, '|'),) if gather else (), moves=((0, 1),)) + else: + graph.add(loop, after, tests=((0, '|'),), moves=((0, 1),)) + for bit in '01': + if not work: + graph.add(loop, loop, tests=((0, bit),), moves=((0, 1),)) + elif gather: + graph.add(loop, loop, tests=((0, bit),), writes=((work, bit),), + moves=((0, 1), (work, 1))) + else: + for output in '01': + graph.add(loop, loop, tests=((0, bit), (work, output)), + writes=((0, output),), moves=((0, 1), (work, 1))) + next_state = graph.jump(loop, ((work, 1),)) if work else loop + return graph.jump(next_state, ((0, 1),)) + + +def reserve(graph, extra_homes, target): + """Append full zero homes by copying first-field extent, without F arithmetic.""" + if not extra_homes: + return target + return_home = graph.rewind(0, target) + finish = graph.state('reserve-finish') + graph.add(finish, return_home, writes=((0, '$'),)) + next_state = graph.rewind(3, finish, erase=True) + for position in range(extra_homes-1,-1,-1): + loop = graph.state('reserve-zero-home') + graph.add(loop, loop, tests=((3, '0'),), writes=((0, '0'),), moves=((0, 1),(3, 1))) + graph.add(loop, next_state, tests=((3, '|'),), writes=((0, '|'),), moves=((0, 1),)) + begin = graph.jump(loop, ((3, 1),)) + next_state = graph.rewind(3, begin) if position else begin + seek = graph.state('reserve-seek-end') + graph.add(seek, next_state, tests=((0, '$'),)) + for symbol in '^01|': + graph.add(seek, seek, tests=((0, symbol),), moves=((0, 1),)) + rewind_template = graph.rewind(3, seek) + rewind_home = graph.rewind(0, rewind_template) + copy = graph.state('reserve-copy-extent') + for bit in '01': + graph.add(copy, copy, tests=((0, bit),), writes=((3, '0'),), moves=((0, 1),(3, 1))) + graph.add(copy, rewind_home, tests=((0, '|'),), writes=((3, '|'),)) + return graph.jump(copy, ((0, 1),(3, 1))) + + +def compile_graph(events, owners, primitive=service, productive_count=None): + """Return a real transition graph on four tapes for the fixture family. + + General theorem: replace primitive by supplied finite graphs using m + scratch tapes; tape count is 1+b+m, independently of Q,K,F. + """ + graph, next_state = Graph(), 'HALT' + home_index = {owner: i for i, owner in enumerate(owners)} + if len(home_index) != len(owners): + raise ValueError('permanent home owner identities must be distinct') + for index in range(len(events)-1, -1, -1): + event = events[index] + if not event.service: + continue + graph.checkpoints[next_state] = index + if not 1 <= len(event.owners) <= 2 or len(set(event.owners)) != len(event.owners): + raise ValueError('bounded distinct physical operands') + selected = {home_index[owner]: i+1 for i, owner in enumerate(event.owners)} + cleanup = next_state + for tape in range(len(event.owners), 0, -1): + cleanup = graph.rewind(tape, cleanup, erase=True) + scatter = scan(graph, len(owners), selected, False, cleanup) + invoke = primitive(graph, event.service, len(event.owners), scatter) + origin = invoke + for tape in range(len(event.owners), 0, -1): + origin = graph.rewind(tape, origin) + next_state = scan(graph, len(owners), selected, True, origin) + graph.execution_start = next_state + productive_count = len(owners) if productive_count is None else productive_count + if not 1 <= productive_count <= len(owners): + raise ValueError('positive productive count within permanent bank') + graph.start = reserve(graph,len(owners)-productive_count,next_state) + graph.validate() + return graph + + +def initial_tapes(payloads, home_count, preformatted=False): + if not payloads or len({len(x) for x in payloads}) != 1 or not payloads[0]: + raise ValueError('positive common full field format') + if len(payloads) > home_count or any(set(x)-set('01') for x in payloads): + raise ValueError('binary productive bank in declared homes') + # Only productive fields are supplied. New private extents are prepared + # by the literal reserve graph. Optional preformatting is for fault tests. + fields = list(payloads) + if preformatted: + fields += ['0'*len(payloads[0])]*(home_count-len(payloads)) + return [Tape('^'+'|'.join(fields)+'|$'), Tape(), Tape(), Tape()] + + +def decoded(tapes, home_count): + raw = tapes[0].contents() + if raw[0] != '^' or not raw.endswith('|$'): + raise ValueError('home boundaries changed') + fields = tuple(raw[1:-2].split('|')) + if len(fields) != home_count: + raise ValueError('permanent home count changed') + return fields diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md new file mode 100644 index 0000000000..71c5f6dae2 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and license + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +New material is Apache-2.0; copied predecessors retain their original notices. + +Jose Manuel (jmbarrancoml), CrocSwap/integer-mult-bounds#3091, supplies the +Gaussian C numerator rows, exact carry/parity/signed-fit argument, physical +complete-axis strategy and direct tensor tariff. Credit its #3055/#3087 +physical lineage, Alejandro Zarzuelo Urdiales's #45 Gaussian tensor reserve +and norm results, James Chang's #1869 ripple arithmetic, AAAmirinu's #2327 +prefix audit, and Nick Petalas's #2772/#3089 prefix/capacity work. + +@CubeJerry's #6967 current-coded leaf supplies the earlier source/format/ +lifecycle binding and explicitly leaves literal numerical export open. +#6978, #6986 and #6989 provide distinct all-source, cutoff-transport and +rounded wrappers. Their stronger failure-retirement and old coded interfaces +are not silently inherited by this packed component. + +The actual #7000 source, Clifford compiler and retained independent Gaussian +verifier are credited to DreamingOfClouds, Ali Romman, Cinna Davis, zxv, +unpaidmoon, icekylinx, CubeJerry and the earlier authors named by the retained +sources. The construction, lowering and matrix identities are not claimed anew. + +The packed ABI is published at +`172f4535ce8dcff79f626410af845f757c1563be`. Unary/Gamma/trace patterns follow +literal-layer-phase at `8b549ca6557ccbb3017b104b27ea35051f990416`, which credits +literal-layer-egress at `51ab0539059214fcfa044938c36a0b6017232be5`. The exact +Builder/Machine originates in #7349, head +`9dfe6747b8553fd11b408f2b045c5954ef1e6eaa`. + +The parent's dense execution/oracle and literal_layer_boundary's independent +source/Gaussian/universal-cost review are separately attributed in REVIEW.md. +Their artifacts are unchanged. Independent AI work is not human approval or +formal proof-kernel acceptance. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py new file mode 100644 index 0000000000..3ab6d0361f --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py @@ -0,0 +1,112 @@ +"""Finite three-tape online rank-recursion control; Apache-2.0. +Only PC and local symbols affect execution. Metrics/event logs are observers. +""" +from dataclasses import dataclass, field +BLANK, ONE, MARK = '_', '1', '|' +WIDTH, CHILD, STACK = range(3) + +class Builder: + def __init__(self): self.code, self.labels, self.serial = [], {}, 0 + def mark(self,n): + if n in self.labels: raise ValueError('duplicate label') + self.labels[n]=len(self.code) + def op(self,*x): self.code.append(x) + def rewind(self,t,symbols): + self.serial+=1; loop=f'rw{self.serial}'; done=loop+'done' + self.op('move',t,-1); self.mark(loop) + self.op('read',t,{s:loop+'step' for s in symbols}|{MARK:done}) + self.mark(loop+'step'); self.op('move',t,-1); self.op('goto',loop) + self.mark(done); self.op('move',t,1) + def finish(self,alphabet): + result=[] + for op,*a in self.code: + if op=='goto': a[0]=self.labels[a[0]] + elif op=='read': a[1]={s:self.labels[n] for s,n in a[1].items()} + result.append((op,*a)) + return tuple(result),tuple(alphabet) + +def compile_controller(m,ranks): + """Parameters are compile-time constants, absent from run-time state.""" + if type(m) is not int or m<2 or not ranks: raise ValueError('bad fixed profile') + if any(type(r) is not int or not 1<=r=budget: raise ValueError('finite verifier budget') + self.step() + return self + +def initial_tapes(width,origins=(0,0,0),ancestor=('0','1','t0','_','|','0')): + if width<1: raise ValueError('positive width') + u,c,p=origins + return [Tape({u-1:MARK,**{u+i:ONE for i in range(width)}},u),Tape({c-1:MARK},c), + Tape({p-1:MARK,**{p-2-i:s for i,s in enumerate(ancestor) if s!=BLANK}},p)] diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/leaf.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/leaf.py new file mode 100644 index 0000000000..bdcc80cbd8 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/leaf/leaf.py @@ -0,0 +1,564 @@ +"""Literal positive rank-one Gaussian C tensor leaf on a packed m=9 field. + +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Apache-2.0. C arithmetic and tensor algebra are credited #3091 predecessors. +Only fixed local instructions execute; encoded inputs do not specialize code. +""" +from pathlib import Path +import hashlib +import sys + +HERE = Path(__file__).resolve().parent +MACHINE = HERE / 'inputs' / 'controller_reference.py' +EXPECTED_MACHINE = 'e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73' +if hashlib.sha256(MACHINE.read_bytes()).hexdigest() != EXPECTED_MACHINE: + raise ValueError('frozen literal machine source drift') +sys.path.insert(0, str(MACHINE.parent)) +from controller_reference import Builder, Machine, Tape, BLANK, ONE, MARK + +(HEADER, DATA, A, B, MODE, HTRACE, LENGTH, DOUBLE, F, R, P, S, WIDTH, + FBIN, FLEN, TBIN, TLEN, PREFIX, SUFFIX, LEFT, RIGHT, LOUT, ROUT, + AR, AI, BR, BI, NUM, DTRACE) = range(29) +PRIVATE = tuple(range(2, 29)) +BITS = ('0', ONE) +INPUTS = (AR, AI, BR, BI) +ROWS = ((1, -1, 1, 1), (1, 1, -1, 1), + (1, 1, 1, -1), (-1, 1, 1, 1)) +NATIVE_DIMENSION = 9 + + +def fresh(a, stem): + a.serial += 1 + return stem + str(a.serial) + + +def clear(a, tape, symbols=(ONE,)): + k = fresh(a, 'clear') + a.mark(k) + a.op('read', tape, {s: k+'bit' for s in symbols} | {BLANK: k+'done'}) + a.mark(k+'bit') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + + +def unary_copy(a, source, target, *, repeat=1, extra=0, erase=False): + k = fresh(a, 'copy') + a.mark(k) + a.op('read', source, {ONE: k+'bit', BLANK: k+'done'}) + a.mark(k+'bit') + for _ in range(repeat): + a.op('write', target, ONE) + a.op('move', target, 1) + if erase: + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('goto', k) + a.mark(k+'done') + for _ in range(extra): + a.op('write', target, ONE) + a.op('move', target, 1) + a.rewind(source, (BLANK,) if erase else (ONE,)) + a.rewind(target, (ONE,)) + + +def trace_return(a, tape, trace): + k = fresh(a, 'return') + a.op('move', trace, -1) + a.mark(k) + a.op('read', trace, {ONE: k+'bit', MARK: k+'done'}) + a.mark(k+'bit') + a.op('write', trace, BLANK) + a.op('move', trace, -1) + a.op('move', tape, -1) + a.op('goto', k) + a.mark(k+'done') + a.op('move', trace, 1) + + +def header_step(a): + a.op('write', HTRACE, ONE) + a.op('move', HTRACE, 1) + a.op('move', HEADER, 1) + + +def gamma(a, target, capture=None): + """Unary decode for parameters bounded by the actual field volume.""" + k = fresh(a, 'gamma') + a.mark(k+'prefix') + a.op('read', HEADER, {'0': k+'zero', ONE: k+'one'}) + a.mark(k+'zero') + a.op('write', LENGTH, ONE) + a.op('move', LENGTH, 1) + header_step(a) + a.op('goto', k+'prefix') + a.mark(k+'one') + header_step(a) + a.op('write', target, ONE) + if capture: + for tape, bit in ((capture[0], ONE), (capture[1], ONE)): + a.op('write', tape, bit) + a.op('move', tape, 1) + a.op('move', LENGTH, -1) + a.mark(k+'tail') + a.op('read', LENGTH, {ONE: k+'tailbit', MARK: k+'done'}) + a.mark(k+'tailbit') + a.op('write', LENGTH, BLANK) + a.op('read', HEADER, {str(b): k+'digit'+str(b) for b in (0, 1)}) + for bit in (0, 1): + a.mark(k+'digit'+str(bit)) + unary_copy(a, target, DOUBLE, repeat=2, extra=bit) + clear(a, target) + unary_copy(a, DOUBLE, target, erase=True) + if capture: + for tape, symbol in ((capture[0], str(bit)), (capture[1], ONE)): + a.op('write', tape, symbol) + a.op('move', tape, 1) + header_step(a) + a.op('move', LENGTH, -1) + a.op('goto', k+'tail') + a.mark(k+'done') + a.op('move', LENGTH, 1) + if capture: + a.rewind(capture[0], BITS) + a.rewind(capture[1], (ONE,)) + + +def gamma_binary(a): + """Keep cutoff in binary: its represented value can exceed V arbitrarily.""" + k = fresh(a, 'threshold') + a.mark(k+'prefix') + a.op('read', HEADER, {'0': k+'zero', ONE: k+'one'}) + a.mark(k+'zero') + a.op('write', LENGTH, ONE) + a.op('move', LENGTH, 1) + header_step(a) + a.op('goto', k+'prefix') + a.mark(k+'one') + a.op('write', TBIN, ONE) + a.op('move', TBIN, 1) + a.op('write', TLEN, ONE) + a.op('move', TLEN, 1) + header_step(a) + a.op('move', LENGTH, -1) + a.mark(k+'tail') + a.op('read', LENGTH, {ONE: k+'read', MARK: k+'done'}) + a.mark(k+'read') + a.op('write', LENGTH, BLANK) + a.op('read', HEADER, {str(b): k+str(b) for b in (0, 1)}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', TBIN, bit) + a.op('move', TBIN, 1) + a.op('write', TLEN, ONE) + a.op('move', TLEN, 1) + header_step(a) + a.op('move', LENGTH, -1) + a.op('goto', k+'tail') + a.mark(k+'done') + a.op('move', LENGTH, 1) + a.rewind(TBIN, BITS) + a.rewind(TLEN, (ONE,)) + + +def cutoff_guard(a): + k = fresh(a, 'compare') + a.mark(k+'length') + a.op('read', FLEN, {ONE: k+'fmore', BLANK: k+'fend'}) + a.mark(k+'fmore') + a.op('read', TLEN, {ONE: k+'step', BLANK: 'reject'}) + a.mark(k+'step') + a.op('move', FLEN, 1) + a.op('move', TLEN, 1) + a.op('goto', k+'length') + a.mark(k+'fend') + a.op('read', TLEN, {ONE: k+'done', BLANK: k+'equal_length'}) + a.mark(k+'equal_length') + a.rewind(FLEN, (ONE,)) + a.rewind(TLEN, (ONE,)) + a.mark(k+'lex') + a.op('read', FBIN, {'0': k+'f0', ONE: k+'f1', BLANK: k+'equal'}) + a.mark(k+'f0') + a.op('read', TBIN, {'0': k+'same', ONE: k+'done'}) + a.mark(k+'f1') + a.op('read', TBIN, {'0': 'reject', ONE: k+'same'}) + a.mark(k+'same') + a.op('move', FBIN, 1) + a.op('move', TBIN, 1) + a.op('goto', k+'lex') + a.mark(k+'equal') + a.op('read', TBIN, {BLANK: k+'done'}) + a.mark(k+'done') + for tape, symbols in ((FLEN, (ONE,)), (TLEN, (ONE,)), (FBIN, BITS), (TBIN, BITS)): + a.rewind(tape, symbols) + clear(a, tape, symbols) + + +def double(a, tape): + unary_copy(a, tape, DOUBLE, repeat=2) + clear(a, tape) + unary_copy(a, DOUBLE, tape, erase=True) + + +def halve(a, tape): + k = fresh(a, 'halve') + a.mark(k) + a.op('read', tape, {ONE: k+'first', BLANK: k+'done'}) + a.mark(k+'first') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('read', tape, {ONE: k+'second', BLANK: 'reject'}) + a.mark(k+'second') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('write', DOUBLE, ONE) + a.op('move', DOUBLE, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + a.rewind(DOUBLE, (ONE,)) + unary_copy(a, DOUBLE, tape, erase=True) + + +def product(a, left, right, target): + k = fresh(a, 'product') + a.mark(k+'outer') + a.op('read', left, {ONE: k+'inner', BLANK: k+'done'}) + a.mark(k+'inner') + a.op('read', right, {ONE: k+'bit', BLANK: k+'row'}) + a.mark(k+'bit') + a.op('write', target, ONE) + a.op('move', target, 1) + a.op('move', right, 1) + a.op('goto', k+'inner') + a.mark(k+'row') + a.rewind(right, (ONE,)) + a.op('move', left, 1) + a.op('goto', k+'outer') + a.mark(k+'done') + a.rewind(left, (ONE,)) + a.rewind(target, (ONE,)) + + +def geometry(a): + product(a, S, R, SUFFIX) + unary_copy(a, P, PREFIX) + k = fresh(a, 'geometry') + a.mark(k+'suffix') + a.op('read', F, {ONE: k+'block', BLANK: k+'suffix_done'}) + a.mark(k+'block') + for _ in range(NATIVE_DIMENSION-1): + double(a, SUFFIX) + a.op('move', F, 1) + a.op('goto', k+'suffix') + a.mark(k+'suffix_done') + a.rewind(F, (ONE,)) + a.op('move', F, 1) + a.mark(k+'prefix') + a.op('read', F, {ONE: k+'more', BLANK: k+'done'}) + a.mark(k+'more') + double(a, PREFIX) + a.op('move', F, 1) + a.op('goto', k+'prefix') + a.mark(k+'done') + a.rewind(F, (ONE,)) + for tape in (P, R, S): + clear(a, tape) + + +def copy_width(a, source, target, *, rewind_target=False): + k = fresh(a, 'widthcopy') + a.mark(k) + a.op('read', WIDTH, {ONE: k+'read', BLANK: k+'done'}) + a.mark(k+'read') + a.op('read', source, {str(b): k+str(b) for b in (0, 1)}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', target, bit) + a.op('move', target, 1) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('move', WIDTH, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(WIDTH, (ONE,)) + if rewind_target: + a.rewind(target, BITS) + + +def load_suffix(a, source, target): + k = fresh(a, 'suffix') + a.mark(k) + a.op('read', SUFFIX, {ONE: k+'pair', BLANK: k+'done'}) + a.mark(k+'pair') + for _ in range(2): + copy_width(a, source, target) + a.op('move', SUFFIX, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(SUFFIX, (ONE,)) + a.rewind(target, BITS) + + +def emit_stream(a, source, target): + k = fresh(a, 'stream') + a.mark(k) + a.op('read', source, {str(b): k+str(b) for b in (0, 1)} | {BLANK: k+'done'}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', target, bit) + a.op('move', target, 1) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(source, (BLANK,)) + + +def tuple_branch(a, label, emit, prefix=()): + """Compile the fixed sixteen branches of a four-symbol read.""" + name = label+''.join(map(str, prefix)) + a.mark(name) + if len(prefix) == 4: + emit(prefix) + else: + a.op('read', INPUTS[len(prefix)], {str(b): name+str(b) for b in (0, 1)}) + for bit in (0, 1): + tuple_branch(a, label, emit, prefix+(bit,)) + + +def c_component(a, signs, output): + """Exact four-input numerator, two sign extensions, halving and fit.""" + k = fresh(a, 'C') + a.mark(k+'seek') + a.op('read', WIDTH, {ONE: k+'seekbit', BLANK: k+'seekend'}) + a.mark(k+'seekbit') + for tape in INPUTS: + a.op('move', tape, 1) + a.op('move', WIDTH, 1) + a.op('goto', k+'seek') + a.mark(k+'seekend') + a.rewind(WIDTH, (ONE,)) + for tape in INPUTS: + a.op('move', tape, -1) + a.op('goto', k+'digit0') + for carry in (-1, 0, 1, 2): + label = k+'digit'+str(carry) + a.mark(label) + a.op('read', WIDTH, {ONE: label+'read', BLANK: k+'extend'+str(carry)}) + def digit(bits, carry=carry): + total = carry+sum(s*b for s, b in zip(signs, bits)) + a.op('write', NUM, str(total % 2)) + a.op('move', NUM, 1) + for tape in INPUTS: + a.op('move', tape, -1) + a.op('move', WIDTH, 1) + a.op('goto', k+'digit'+str(total//2)) + tuple_branch(a, label+'read', digit) + a.mark(k+'extend'+str(carry)) + for tape in INPUTS: + a.op('move', tape, 1) + a.rewind(WIDTH, (ONE,)) + a.op('goto', k+'sign1c'+str(carry)) + for stage in (1, 2): + for carry in (-1, 0, 1, 2): + def extension(bits, carry=carry, stage=stage): + total = carry+sum(s*b for s, b in zip(signs, bits)) + a.op('write', NUM, str(total % 2)) + a.op('move', NUM, 1) + a.op('goto', k+'sign2c'+str(total//2) if stage == 1 else k+'check') + tuple_branch(a, k+'sign'+str(stage)+'c'+str(carry), extension) + a.mark(k+'check') + a.rewind(NUM, BITS) + a.op('read', NUM, {'0': k+'even', ONE: 'reject'}) + a.mark(k+'even') + a.op('write', NUM, BLANK) + a.op('move', NUM, 1) + a.mark(k+'highseek') + a.op('read', NUM, {'0': k+'highstep', ONE: k+'highstep', BLANK: k+'highend'}) + a.mark(k+'highstep') + a.op('move', NUM, 1) + a.op('goto', k+'highseek') + a.mark(k+'highend') + a.op('move', NUM, -1) + a.op('read', NUM, {str(b): k+'top'+str(b) for b in (0, 1)}) + for bit in ('0', ONE): + a.mark(k+'top'+bit) + a.op('write', NUM, BLANK) + a.op('move', NUM, -1) + a.op('read', NUM, {bit: k+'emit'}) + a.mark(k+'emit') + a.op('read', WIDTH, {ONE: k+'emitread', BLANK: k+'done'}) + a.mark(k+'emitread') + a.op('read', NUM, {str(b): k+'emit'+str(b) for b in (0, 1)}) + for bit in ('0', ONE): + a.mark(k+'emit'+bit) + a.op('write', output, bit) + a.op('move', output, 1) + a.op('write', NUM, BLANK) + a.op('move', NUM, -1) + a.op('move', WIDTH, 1) + a.op('goto', k+'emit') + a.mark(k+'done') + a.rewind(WIDTH, (ONE,)) + + +def clone_source(a): + """Clone exactly the generated volume; reject short/excess cardinality.""" + k = fresh(a, 'clone') + a.mark(k+'prefix') + a.op('read', PREFIX, {ONE: k+'blocks', BLANK: k+'done'}) + a.mark(k+'blocks') + for side in range(2): + name = k+'side'+str(side) + a.mark(name) + a.op('read', SUFFIX, {ONE: name+'coefficient', BLANK: name+'done'}) + a.mark(name+'coefficient') + for component in range(2): + field = name+'field'+str(component) + a.mark(field) + a.op('read', WIDTH, {ONE: field+'read', BLANK: field+'done'}) + a.mark(field+'read') + a.op('read', DATA, {str(b): field+str(b) for b in (0, 1)}) + for bit in ('0', ONE): + a.mark(field+bit) + a.op('write', A, bit) + a.op('move', A, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('move', WIDTH, 1) + a.op('goto', field) + a.mark(field+'done') + a.rewind(WIDTH, (ONE,)) + a.op('move', SUFFIX, 1) + a.op('goto', name) + a.mark(name+'done') + a.rewind(SUFFIX, (ONE,)) + a.op('move', PREFIX, 1) + a.op('goto', k+'prefix') + a.mark(k+'done') + a.rewind(PREFIX, (ONE,)) + a.op('read', DATA, {BLANK: k+'verified'}) + a.mark(k+'verified') + trace_return(a, DATA, DTRACE) + a.rewind(A, BITS) + + +def commit(a, source): + k = fresh(a, 'commit') + a.mark(k) + a.op('read', source, {str(b): k+str(b) for b in (0, 1)} | {BLANK: k+'done'}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', DATA, bit) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('goto', k) + a.mark(k+'done') + trace_return(a, DATA, DTRACE) + a.rewind(source, (BLANK,)) + + +def compile_leaf(): + a = Builder() + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, MARK) + a.op('move', tape, 1) + gamma(a, F, (FBIN, FLEN)) + for tape in (R, P, S, WIDTH): + gamma(a, tape) + gamma_binary(a) + trace_return(a, HEADER, HTRACE) + cutoff_guard(a) + for i in range(2): + a.op('read', WIDTH, {ONE: 'width'+str(i)}) + a.mark('width'+str(i)) + a.op('move', WIDTH, 1) + a.rewind(WIDTH, (ONE,)) + geometry(a) + clone_source(a) + a.op('write', MODE, '0') + a.mark('prefix') + a.op('read', PREFIX, {ONE: 'load_select', BLANK: 'axis_end'}) + a.mark('load_select') + a.op('read', MODE, {'0': 'loadA', ONE: 'loadB'}) + for mode, source in enumerate((A, B)): + a.mark('load'+('A' if mode == 0 else 'B')) + load_suffix(a, source, LEFT) + load_suffix(a, source, RIGHT) + a.op('goto', 'pairs') + a.mark('pairs') + a.op('read', SUFFIX, {ONE: 'pair', BLANK: 'pairs_done'}) + a.mark('pair') + for source, target in ((LEFT, AR), (LEFT, AI), (RIGHT, BR), (RIGHT, BI)): + copy_width(a, source, target, rewind_target=True) + for signs, output in zip(ROWS, (LOUT, LOUT, ROUT, ROUT)): + c_component(a, signs, output) + for tape in INPUTS: + clear(a, tape, BITS) + a.op('move', SUFFIX, 1) + a.op('goto', 'pairs') + a.mark('pairs_done') + a.rewind(SUFFIX, (ONE,)) + for tape in (LEFT, RIGHT): + a.rewind(tape, (BLANK,)) + for tape in (LOUT, ROUT): + a.rewind(tape, BITS) + a.op('read', MODE, {'0': 'mergeB', ONE: 'mergeA'}) + for name, target in (('mergeB', B), ('mergeA', A)): + a.mark(name) + emit_stream(a, LOUT, target) + emit_stream(a, ROUT, target) + a.op('goto', 'prefix_done') + a.mark('prefix_done') + a.op('move', PREFIX, 1) + a.op('goto', 'prefix') + a.mark('axis_end') + a.op('read', MODE, {'0': 'endA', ONE: 'endB'}) + for mode, source, target in ((0, A, B), (1, B, A)): + name = 'end'+('A' if mode == 0 else 'B') + a.mark(name) + a.op('read', source, {BLANK: name+'valid'}) + a.mark(name+'valid') + a.rewind(source, (BLANK,)) + a.rewind(target, BITS) + a.op('write', MODE, str(1-mode)) + a.op('goto', 'axis_done') + a.mark('axis_done') + a.rewind(PREFIX, (ONE,)) + a.op('move', F, 1) + a.op('read', F, {ONE: 'next_axis', BLANK: 'finish'}) + a.mark('next_axis') + double(a, SUFFIX) + halve(a, PREFIX) + a.op('goto', 'prefix') + a.mark('finish') + a.op('read', MODE, {'0': 'commitA', ONE: 'commitB'}) + for name, source in (('commitA', A), ('commitB', B)): + a.mark(name) + commit(a, source) + a.op('goto', 'retire') + a.mark('retire') + a.rewind(F, (ONE,)) + for tape in (F, WIDTH, PREFIX, SUFFIX): + clear(a, tape) + clear(a, MODE, BITS) + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('halt') + a.mark('reject') + a.op('read', HEADER, {}) + return a.finish((BLANK, '0', ONE, MARK)) + + + + diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md new file mode 100644 index 0000000000..3a3030f23d --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md @@ -0,0 +1,36 @@ +# Attribution and scope + +New construction, source binding, uniform complete-cost proof, author checks +and packaging were prepared for Jerry Chen (@CubeJerry), with substantial +OpenAI assistance. Independent receipts identify the separate executing +reviewer and distinct methods. No human or proof-kernel verification of the +multiplication theorem is claimed. New work is Apache-2.0. + +Credit Matarener's #3825 controlled reversal and #3834's finite identity +check; David Arias's #2776/fixed-tape-ordered-shear split/merge, unary conversion +and local return method; the fixed-tape-affine-shear runtime-coefficient +extension and its credited Charles Bethin unit-carry predecessor; JoyboyBrian's +#5188 complete literal interchange and binary-alphabet successor; Jose Manuel's +physical Gaussian monomial and #3087/#4172 lineage; the selected monomial +record lift; and #6992's current serial-column implication and conditional +bill. These algebraic and routing methods are not new claims here. + +The #7000 selected native/compiler/application-review authors supply the +actual word, exact Clifford lowering, signed Gaussian interpreter and phase +conventions. Their retained source notices are unchanged. + +The published controller `9dfe6747b8553fd11b408f2b045c5954ef1e6eaa` supplies +Builder/Machine/Tape. The literal layer phase +`8b549ca6557ccbb3017b104b27ea35051f990416`, selected quadratic phase +`172f4535ce8dcff79f626410af845f757c1563be`, and positive C leaf +`1a555e469b89af70d309bc966f8f813ac11dc887` supply the shared packed interface +and reusable local acquisition/copy/return patterns. Exact reference copies +and source pins are retained. The new `fresh` adds a label delimiter to avoid +decimal label collisions in the larger compile-time word. + +C4's dense author-test interpreter is retained as a source reference. This +package changes its fixed inventory from 29 to 27 and raises only its external +watchdog. That reuse is not presented as independently written review. Root's +independent interpreter/oracle were written separately and are retained +unchanged. No invented PR number is used for newly published fork branches; +they are identified by exact commits until a PR exists. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py new file mode 100644 index 0000000000..3ab6d0361f --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py @@ -0,0 +1,112 @@ +"""Finite three-tape online rank-recursion control; Apache-2.0. +Only PC and local symbols affect execution. Metrics/event logs are observers. +""" +from dataclasses import dataclass, field +BLANK, ONE, MARK = '_', '1', '|' +WIDTH, CHILD, STACK = range(3) + +class Builder: + def __init__(self): self.code, self.labels, self.serial = [], {}, 0 + def mark(self,n): + if n in self.labels: raise ValueError('duplicate label') + self.labels[n]=len(self.code) + def op(self,*x): self.code.append(x) + def rewind(self,t,symbols): + self.serial+=1; loop=f'rw{self.serial}'; done=loop+'done' + self.op('move',t,-1); self.mark(loop) + self.op('read',t,{s:loop+'step' for s in symbols}|{MARK:done}) + self.mark(loop+'step'); self.op('move',t,-1); self.op('goto',loop) + self.mark(done); self.op('move',t,1) + def finish(self,alphabet): + result=[] + for op,*a in self.code: + if op=='goto': a[0]=self.labels[a[0]] + elif op=='read': a[1]={s:self.labels[n] for s,n in a[1].items()} + result.append((op,*a)) + return tuple(result),tuple(alphabet) + +def compile_controller(m,ranks): + """Parameters are compile-time constants, absent from run-time state.""" + if type(m) is not int or m<2 or not ranks: raise ValueError('bad fixed profile') + if any(type(r) is not int or not 1<=r=budget: raise ValueError('finite verifier budget') + self.step() + return self + +def initial_tapes(width,origins=(0,0,0),ancestor=('0','1','t0','_','|','0')): + if width<1: raise ValueError('positive width') + u,c,p=origins + return [Tape({u-1:MARK,**{u+i:ONE for i in range(width)}},u),Tape({c-1:MARK},c), + Tape({p-1:MARK,**{p-2-i:s for i,s in enumerate(ancestor) if s!=BLANK}},p)] diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/linear.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/linear.py new file mode 100644 index 0000000000..6aad40a6c4 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/linear/linear.py @@ -0,0 +1,435 @@ +"""Literal selected nine-coordinate linear maps on a packed Gaussian field. + +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Apache-2.0. Split/merge, unary clocks and CNOT decomposition are credited +predecessor methods; this is their exact encoded all-column selected join. +""" +from pathlib import Path +import hashlib +import sys + +HERE = Path(__file__).resolve().parent +MACHINE = HERE/'inputs/controller_reference.py' +EXPECTED_MACHINE = 'e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73' +if hashlib.sha256(MACHINE.read_bytes()).hexdigest() != EXPECTED_MACHINE: + raise ValueError('frozen local machine source drift') +sys.path.insert(0, str(MACHINE.parent)) +from controller_reference import Builder, Machine, Tape, BLANK, ONE, MARK + +(HEADER, DATA, A, B, MODE, HTRACE, LENGTH, DOUBLE, F, R, P, S, WIDTH, + VOLUME, AUX, PREFIX, MIDDLE, BLOCK, LEFT, RIGHT, LOUT, ROUT, + Q0, Q1, Q2, Q3, DTRACE) = range(27) +PRIVATE = tuple(range(2, 27)) +BITS = ('0', ONE) +CHUNKS = (Q0, Q1, Q2, Q3) +MATRICES = { + 'right': (239,129,130,132,136,16,160,192,256), + 'left': (3,5,9,17,32,65,129,1,256), +} +DIMENSION = 9 + + +def cnot_word(rows): + """Fixed-data Gaussian elimination; no input header is consulted.""" + if len(rows) != DIMENSION or any(type(x) is not int or not 0 <= x < 1 << DIMENSION for x in rows): + raise ValueError('fixed nine-coordinate matrix') + choices = [] + for order in (range(DIMENSION), range(DIMENSION-1, -1, -1)): + a, eliminated, word = list(rows), set(), [] + def add(target, control): + a[target] ^= a[control] + word.append((target, control)) + for j in order: + if not (a[j] >> j) & 1: + candidates = [i for i in range(DIMENSION) if i not in eliminated and (a[i] >> j) & 1] + if not candidates: + raise ValueError('singular fixed matrix') + k = candidates[0] + add(j, k); add(k, j); add(j, k) + for i in range(DIMENSION): + if i != j and (a[i] >> j) & 1: + add(i, j) + eliminated.add(j) + if a != [1 << i for i in range(DIMENSION)]: + raise ValueError('fixed elimination invariant') + choices.append(tuple(reversed(word))) + return min(choices, key=lambda x: (len(x), x)) + + +def fresh(a, stem): + a.serial += 1 + return stem + str(a.serial) + '_' + + + +def clear(a, tape, symbols=(ONE,)): + k = fresh(a, 'clear') + a.mark(k) + a.op('read', tape, {s: k+'bit' for s in symbols} | {BLANK: k+'done'}) + a.mark(k+'bit') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + + + +def unary_copy(a, source, target, *, repeat=1, extra=0, erase=False): + k = fresh(a, 'copy') + a.mark(k) + a.op('read', source, {ONE: k+'bit', BLANK: k+'done'}) + a.mark(k+'bit') + for _ in range(repeat): + a.op('write', target, ONE) + a.op('move', target, 1) + if erase: + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('goto', k) + a.mark(k+'done') + for _ in range(extra): + a.op('write', target, ONE) + a.op('move', target, 1) + a.rewind(source, (BLANK,) if erase else (ONE,)) + a.rewind(target, (ONE,)) + + + +def header_step(a): + a.op('write', HTRACE, ONE) + a.op('move', HTRACE, 1) + a.op('move', HEADER, 1) + + + +def gamma(a, target): + """Actual positive Gamma code to unary, using only literal operations.""" + k = fresh(a, 'gamma') + a.mark(k+'prefix') + a.op('read', HEADER, {'0': k+'zero', ONE: k+'one'}) + a.mark(k+'zero') + a.op('write', LENGTH, ONE) + a.op('move', LENGTH, 1) + header_step(a) + a.op('goto', k+'prefix') + a.mark(k+'one') + header_step(a) + a.op('write', target, ONE) + a.op('move', LENGTH, -1) + a.mark(k+'tail') + a.op('read', LENGTH, {ONE: k+'tailbit', MARK: k+'done'}) + a.mark(k+'tailbit') + a.op('write', LENGTH, BLANK) + a.op('read', HEADER, {str(b): k+'digit'+str(b) for b in (0, 1)}) + for b in (0, 1): + a.mark(k+'digit'+str(b)) + unary_copy(a, target, DOUBLE, repeat=2, extra=b) + clear(a, target) + unary_copy(a, DOUBLE, target, erase=True) + header_step(a) + a.op('move', LENGTH, -1) + a.op('goto', k+'tail') + a.mark(k+'done') + a.op('move', LENGTH, 1) + + + +def trace_return(a, tape, trace): + k = fresh(a, 'return') + a.op('move', trace, -1) + a.mark(k) + a.op('read', trace, {ONE: k+'bit', MARK: k+'done'}) + a.mark(k+'bit') + a.op('write', trace, BLANK) + a.op('move', trace, -1) + a.op('move', tape, -1) + a.op('goto', k) + a.mark(k+'done') + a.op('move', trace, 1) + + + +def double(a, tape): + unary_copy(a, tape, DOUBLE, repeat=2) + clear(a, tape) + unary_copy(a, DOUBLE, tape, erase=True) + + + +def halve(a, tape): + k = fresh(a, 'halve') + a.mark(k) + a.op('read', tape, {ONE: k+'first', BLANK: k+'done'}) + a.mark(k+'first') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('read', tape, {ONE: k+'second', BLANK: 'reject'}) + a.mark(k+'second') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('write', DOUBLE, ONE) + a.op('move', DOUBLE, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + a.rewind(DOUBLE, (ONE,)) + unary_copy(a, DOUBLE, tape, erase=True) + + + +def product(a, left, right, target): + k = fresh(a, 'product') + a.mark(k+'outer') + a.op('read', left, {ONE: k+'inner', BLANK: k+'done'}) + a.mark(k+'inner') + a.op('read', right, {ONE: k+'bit', BLANK: k+'row'}) + a.mark(k+'bit') + a.op('write', target, ONE) + a.op('move', target, 1) + a.op('move', right, 1) + a.op('goto', k+'inner') + a.mark(k+'row') + a.rewind(right, (ONE,)) + a.op('move', left, 1) + a.op('goto', k+'outer') + a.mark(k+'done') + a.rewind(left, (ONE,)) + a.rewind(target, (ONE,)) + + + +def emit_stream(a, source, target): + k = fresh(a, 'stream') + a.mark(k) + a.op('read', source, {str(b): k+str(b) for b in (0, 1)} | {BLANK: k+'done'}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', target, bit) + a.op('move', target, 1) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(source, (BLANK,)) + + + +def commit(a, source): + k = fresh(a, 'commit') + a.mark(k) + a.op('read', source, {str(b): k+str(b) for b in (0, 1)} | {BLANK: k+'done'}) + for bit in ('0', ONE): + a.mark(k+bit) + a.op('write', DATA, bit) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('goto', k) + a.mark(k+'done') + trace_return(a, DATA, DTRACE) + a.rewind(source, (BLANK,)) + + + +def multiply_guide(a, target, factor): + product(a, target, factor, AUX) + clear(a, target) + unary_copy(a, AUX, target, erase=True) + + +def column_doublings(a, target, times): + """times is fixed construction data; the actual F loop survives.""" + k = fresh(a, 'column_double') + a.mark(k) + a.op('read', F, {ONE: k+'more', BLANK: k+'done'}) + a.mark(k+'more') + for _ in range(times): + double(a, target) + a.op('move', F, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(F, (ONE,)) + + +def volume(a): + unary_copy(a, P, VOLUME) + for factor in (R, S, WIDTH): + multiply_guide(a, VOLUME, factor) + column_doublings(a, VOLUME, DIMENSION) + double(a, VOLUME) + + +def geometry(a, high, low): + # At j=0: A=P*2^((high+1)f-1), M=2^((low-high)f-1), + # B=2wrS*2^((8-low)f). Temporary doubles are also paid. + unary_copy(a, P, PREFIX) + column_doublings(a, PREFIX, high+1) + halve(a, PREFIX) + a.op('write', MIDDLE, ONE) + column_doublings(a, MIDDLE, low-high) + halve(a, MIDDLE) + product(a, R, S, BLOCK) + multiply_guide(a, BLOCK, WIDTH) + double(a, BLOCK) + column_doublings(a, BLOCK, DIMENSION-1-low) + + +def clone(a): + k = fresh(a, 'clone') + a.mark(k) + a.op('read', VOLUME, {ONE: k+'read', BLANK: k+'done'}) + a.mark(k+'read') + a.op('read', DATA, {str(b): k+str(b) for b in (0, 1)}) + for bit in BITS: + a.mark(k+bit) + a.op('write', A, bit) + a.op('move', A, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('move', VOLUME, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(VOLUME, (ONE,)) + a.op('read', DATA, {BLANK: k+'valid'}) + a.mark(k+'valid') + trace_return(a, DATA, DTRACE) + a.rewind(A, BITS) + + +def copy_block(a, source, target, *, return_target=False): + k = fresh(a, 'block_copy') + a.mark(k) + a.op('read', BLOCK, {ONE: k+'read', BLANK: k+'done'}) + a.mark(k+'read') + a.op('read', source, {str(b): k+str(b) for b in (0, 1)}) + for bit in BITS: + a.mark(k+bit) + a.op('write', target, bit) + a.op('move', target, 1) + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('move', BLOCK, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(BLOCK, (ONE,)) + if return_target: + a.rewind(target, BITS) + + +def load_half(a, source, target): + k = fresh(a, 'half') + a.mark(k) + a.op('read', MIDDLE, {ONE: k+'two', BLANK: k+'done'}) + a.mark(k+'two') + for _ in range(2): + copy_block(a, source, target) + a.op('move', MIDDLE, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(MIDDLE, (ONE,)) + a.rewind(target, BITS) + + +def cnot_columns(a, target, control): + """All encoded F columns of one fixed CNOT, both physical directions.""" + high, low = min(target, control), max(target, control) + permutation = (0, 1, 3, 2) if control == high else (0, 3, 2, 1) + geometry(a, high, low) + k = fresh(a, 'cnot') + a.mark(k+'prefix') + a.op('read', PREFIX, {ONE: k+'load_select', BLANK: k+'end'}) + a.mark(k+'load_select') + a.op('read', MODE, {'0': k+'loadA', ONE: k+'loadB'}) + for source, label in ((A, 'A'), (B, 'B')): + a.mark(k+'load'+label) + load_half(a, source, LEFT) + load_half(a, source, RIGHT) + a.op('goto', k+'middle') + a.mark(k+'middle') + a.op('read', MIDDLE, {ONE: k+'chunks', BLANK: k+'middle_done'}) + a.mark(k+'chunks') + for source, chunk in ((LEFT, Q0), (LEFT, Q1), (RIGHT, Q2), (RIGHT, Q3)): + copy_block(a, source, chunk, return_target=True) + for i, index in enumerate(permutation): + emit_stream(a, CHUNKS[index], LOUT if i < 2 else ROUT) + a.op('move', MIDDLE, 1) + a.op('goto', k+'middle') + a.mark(k+'middle_done') + a.rewind(MIDDLE, (ONE,)) + for tape in (LEFT, RIGHT): + a.rewind(tape, (BLANK,)) + for tape in (LOUT, ROUT): + a.rewind(tape, BITS) + a.op('read', MODE, {'0': k+'mergeB', ONE: k+'mergeA'}) + for label, destination in (('mergeB', B), ('mergeA', A)): + a.mark(k+label) + emit_stream(a, LOUT, destination) + emit_stream(a, ROUT, destination) + a.op('goto', k+'prefix_done') + a.mark(k+'prefix_done') + a.op('move', PREFIX, 1) + a.op('goto', k+'prefix') + a.mark(k+'end') + a.op('read', MODE, {'0': k+'endA', ONE: k+'endB'}) + for mode, source, destination in ((0, A, B), (1, B, A)): + label = k+'end'+('A' if mode == 0 else 'B') + a.mark(label) + a.op('read', source, {BLANK: label+'valid'}) + a.mark(label+'valid') + a.rewind(source, (BLANK,)) + a.rewind(destination, BITS) + a.op('write', MODE, str(1-mode)) + a.op('goto', k+'column_done') + a.mark(k+'column_done') + a.rewind(PREFIX, (ONE,)) + a.op('move', F, 1) + a.op('read', F, {ONE: k+'next_column', BLANK: k+'finished'}) + a.mark(k+'next_column') + double(a, BLOCK) + halve(a, PREFIX) + a.op('goto', k+'prefix') + a.mark(k+'finished') + a.rewind(F, (ONE,)) + for tape in (PREFIX, MIDDLE, BLOCK): + clear(a, tape) + + +def compile_linear(side): + """side is fixed construction data: exactly 'left' or 'right'.""" + if side not in MATRICES: + raise ValueError('one of the two selected fixed linear maps is required') + word = cnot_word(MATRICES[side]) + a = Builder() + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, MARK) + a.op('move', tape, 1) + for target in (F, R, P, S, WIDTH): + gamma(a, target) + trace_return(a, HEADER, HTRACE) + volume(a) + clone(a) + a.op('write', MODE, '0') + for target, control in word: + cnot_columns(a, target, control) + a.op('read', MODE, {'0': 'commitA', ONE: 'commitB'}) + for label, source in (('commitA', A), ('commitB', B)): + a.mark(label) + commit(a, source) + a.op('goto', 'retire') + a.mark('retire') + for tape in (F, R, P, S, WIDTH, VOLUME): + clear(a, tape) + clear(a, MODE, BITS) + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('halt') + a.mark('reject') + a.op('read', HEADER, {}) + return a.finish((BLANK, '0', ONE, MARK)) diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/NOTICE b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/NOTICE new file mode 100644 index 0000000000..7a1f1da9c5 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/NOTICE @@ -0,0 +1,11 @@ +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Apache-2.0. New contribution: literal local lowering, scoped proof and package. +Ali Romman/#5375 supplies the incremental phase and repeated constant. +The retained reference files preserve original source text. +#7000 and its native/Gaussian lineage supply the selected source and engines; +credit DreamingOfClouds, Ali Romman, Cinna Davis, zxv, unpaidmoon, icekylinx, +CubeJerry and earlier authors named by the retained source. +C2 literal-layer-phase supplies Gamma and signed staging/return. B1 literal- +layer-egress supplies owner staging, and #7349 the retained literal machine. +Exact original/copy source pins are in SOURCES.json. No predecessor identity, +compiler, source construction or general monomial theorem is claimed as new. diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py new file mode 100644 index 0000000000..3ab6d0361f --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py @@ -0,0 +1,112 @@ +"""Finite three-tape online rank-recursion control; Apache-2.0. +Only PC and local symbols affect execution. Metrics/event logs are observers. +""" +from dataclasses import dataclass, field +BLANK, ONE, MARK = '_', '1', '|' +WIDTH, CHILD, STACK = range(3) + +class Builder: + def __init__(self): self.code, self.labels, self.serial = [], {}, 0 + def mark(self,n): + if n in self.labels: raise ValueError('duplicate label') + self.labels[n]=len(self.code) + def op(self,*x): self.code.append(x) + def rewind(self,t,symbols): + self.serial+=1; loop=f'rw{self.serial}'; done=loop+'done' + self.op('move',t,-1); self.mark(loop) + self.op('read',t,{s:loop+'step' for s in symbols}|{MARK:done}) + self.mark(loop+'step'); self.op('move',t,-1); self.op('goto',loop) + self.mark(done); self.op('move',t,1) + def finish(self,alphabet): + result=[] + for op,*a in self.code: + if op=='goto': a[0]=self.labels[a[0]] + elif op=='read': a[1]={s:self.labels[n] for s,n in a[1].items()} + result.append((op,*a)) + return tuple(result),tuple(alphabet) + +def compile_controller(m,ranks): + """Parameters are compile-time constants, absent from run-time state.""" + if type(m) is not int or m<2 or not ranks: raise ValueError('bad fixed profile') + if any(type(r) is not int or not 1<=r=budget: raise ValueError('finite verifier budget') + self.step() + return self + +def initial_tapes(width,origins=(0,0,0),ancestor=('0','1','t0','_','|','0')): + if width<1: raise ValueError('positive width') + u,c,p=origins + return [Tape({u-1:MARK,**{u+i:ONE for i in range(width)}},u),Tape({c-1:MARK},c), + Tape({p-1:MARK,**{p-2-i:s for i,s in enumerate(ancestor) if s!=BLANK}},p)] diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/phase.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/phase.py new file mode 100644 index 0000000000..d489781458 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/phase/phase.py @@ -0,0 +1,335 @@ +"""Literal selected native quadratic phase, with complete owner commit. + +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Apache-2.0. The multi-counter phase algorithm is credited to #5375. Header, +signed staging and return helpers are retained from the frozen C2 phase. +Only fixed-table read/write/unit-move/goto/halt instructions execute. +""" +from pathlib import Path +import hashlib +import sys + +HERE = Path(__file__).resolve().parent +MACHINE = HERE / 'inputs' / 'controller_reference.py' +EXPECTED_MACHINE = 'e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73' +if hashlib.sha256(MACHINE.read_bytes()).hexdigest() != EXPECTED_MACHINE: + raise ValueError('frozen literal machine source drift') +sys.path.insert(0, str(MACHINE.parent)) +from controller_reference import Builder, Machine, Tape, BLANK, ONE, MARK + +(HEADER, DATA, OUTPUT, HTRACE, LENGTH, DOUBLE, COLUMNS, COEFF, OUTER, + SPECTATOR, WIDTH, REAL, IMAG, DTRACE) = range(14) +COUNTERS = tuple(range(14, 23)) +PRIVATE = tuple(range(2, 23)) +BITS = ('0', ONE) +SELECTED_LINEAR = (3, 3, 3, 3, 0, 3, 3, 2, 0) +SELECTED_ROWS = (111, 111, 111, 111, 0, 111, 111, 0, 0) +SELECTED_CONSTANT = 1 + + +def fresh(a, stem): + a.serial += 1 + return stem + str(a.serial) + + +def clear(a, tape, symbols=(ONE,)): + k = fresh(a, 'clear') + a.mark(k) + a.op('read', tape, {s: k+'bit' for s in symbols} | {BLANK: k+'done'}) + a.mark(k+'bit') + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + + +def unary_copy(a, source, target, *, repeat=1, extra=0, erase=False): + k = fresh(a, 'copy') + a.mark(k) + a.op('read', source, {ONE: k+'bit', BLANK: k+'done'}) + a.mark(k+'bit') + for _ in range(repeat): + a.op('write', target, ONE) + a.op('move', target, 1) + if erase: + a.op('write', source, BLANK) + a.op('move', source, 1) + a.op('goto', k) + a.mark(k+'done') + for _ in range(extra): + a.op('write', target, ONE) + a.op('move', target, 1) + a.rewind(source, (BLANK,) if erase else (ONE,)) + a.rewind(target, (ONE,)) + + +def header_step(a): + a.op('write', HTRACE, ONE) + a.op('move', HTRACE, 1) + a.op('move', HEADER, 1) + + +def gamma(a, target): + """Actual positive Gamma code to unary, using only literal operations.""" + k = fresh(a, 'gamma') + a.mark(k+'prefix') + a.op('read', HEADER, {'0': k+'zero', ONE: k+'one'}) + a.mark(k+'zero') + a.op('write', LENGTH, ONE) + a.op('move', LENGTH, 1) + header_step(a) + a.op('goto', k+'prefix') + a.mark(k+'one') + header_step(a) + a.op('write', target, ONE) + a.op('move', LENGTH, -1) + a.mark(k+'tail') + a.op('read', LENGTH, {ONE: k+'tailbit', MARK: k+'done'}) + a.mark(k+'tailbit') + a.op('write', LENGTH, BLANK) + a.op('read', HEADER, {str(b): k+'digit'+str(b) for b in (0, 1)}) + for b in (0, 1): + a.mark(k+'digit'+str(b)) + unary_copy(a, target, DOUBLE, repeat=2, extra=b) + clear(a, target) + unary_copy(a, DOUBLE, target, erase=True) + header_step(a) + a.op('move', LENGTH, -1) + a.op('goto', k+'tail') + a.mark(k+'done') + a.op('move', LENGTH, 1) + + +def trace_return(a, tape, trace): + k = fresh(a, 'return') + a.op('move', trace, -1) + a.mark(k) + a.op('read', trace, {ONE: k+'bit', MARK: k+'done'}) + a.mark(k+'bit') + a.op('write', trace, BLANK) + a.op('move', trace, -1) + a.op('move', tape, -1) + a.op('goto', k) + a.mark(k+'done') + a.op('move', trace, 1) + + +def load_component(a, target): + k = fresh(a, 'load') + a.mark(k) + a.op('read', WIDTH, {ONE: k+'bit', BLANK: k+'done'}) + a.mark(k+'bit') + a.op('read', DATA, {str(b): k+str(b) for b in (0, 1)}) + for b in (0, 1): + a.mark(k+str(b)) + a.op('write', target, str(b)) + a.op('move', target, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('move', WIDTH, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(WIDTH, (ONE,)) + a.rewind(target, BITS) + + +def negate(a, tape): + """Exact w-bit integer negation; reject the unrepresentable minimum.""" + k = fresh(a, 'neg') + a.mark(k+'seek') + a.op('read', tape, {'0': k+'step', ONE: k+'step', BLANK: k+'last'}) + a.mark(k+'step') + a.op('move', tape, 1) + a.op('goto', k+'seek') + a.mark(k+'last') + a.op('move', tape, -1) + a.op('goto', k+'c1x0y0') + for carry in (0, 1): + for old_sign in (0, 1): + for new_sign in (0, 1): + name = k+f'c{carry}x{old_sign}y{new_sign}' + a.mark(name) + a.op('read', tape, {str(b): name+'b'+str(b) for b in (0, 1)} | + {MARK: 'reject' if old_sign and new_sign else k+'done'}) + for bit in (0, 1): + total = 1-bit+carry + digit, nxt = total % 2, total//2 + a.mark(name+'b'+str(bit)) + a.op('write', tape, str(digit)) + a.op('move', tape, -1) + a.op('goto', k+f'c{nxt}x{bit}y{digit}') + a.mark(k+'done') + a.op('move', tape, 1) + + +def stage_component(a, tape): + k = fresh(a, 'stage') + a.mark(k) + a.op('read', tape, {str(b): k+str(b) for b in (0, 1)} | {BLANK: k+'done'}) + for b in (0, 1): + a.mark(k+str(b)) + a.op('write', OUTPUT, str(b)) + a.op('move', OUTPUT, 1) + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('goto', k) + a.mark(k+'done') + a.rewind(tape, (BLANK,)) + + +def initialize(a, counters, constant): + """Generate f zero bits on each counter and retain constant*f mod 4.""" + a.op('goto', 'initialize0') + for mode in range(4): + name = 'initialize'+str(mode) + a.mark(name) + a.op('read', COLUMNS, {ONE: name+'bit', BLANK: name+'done'}) + a.mark(name+'bit') + for tape in counters: + a.op('write', tape, '0') + a.op('move', tape, 1) + a.op('move', COLUMNS, 1) + a.op('goto', 'initialize'+str((mode+constant) % 4)) + a.mark(name+'done') + a.rewind(COLUMNS, (ONE,)) + for tape in counters: + a.rewind(tape, BITS) + a.op('goto', 'record'+str(mode)) + + +def advance(a, counters, linear, rows): + """Fixed finite lowering of the credited synchronized counter updater.""" + m = len(counters) + for i in range(m): + neighbors = tuple(j for j in range(m) if j != i and + (rows[min(i, j)] >> max(i, j)) & 1) + for mode in range(4): + name = f'advance{i}q{mode}' + a.mark(name) + a.op('read', counters[i], {str(b): name+'b'+str(b) for b in (0, 1)} | + {BLANK: name+'overflow'}) + for bit in (0, 1): + stem = name+'b'+str(bit) + a.mark(stem) + nxt = (mode+(1-2*bit)*linear[i]) % 4 + a.op('goto', stem+f'n0q{nxt}') + for k, j in enumerate(neighbors): + for value in range(4): + label = stem+f'n{k}q{value}' + a.mark(label) + a.op('read', counters[j], { + str(b): stem+f'n{k+1}q{(value+2*b) % 4}' + for b in (0, 1)}) + for value in range(4): + a.mark(stem+f'n{len(neighbors)}q{value}') + a.op('write', counters[i], str(1-bit)) + for tape in counters: + a.op('move', tape, 1) + a.op('goto', f'advance{i}q{value}' if bit else + 'advanced'+str(value)) + a.mark(name+'overflow') + for tape in counters: + target = fresh(a, 'all_end') + a.op('read', tape, {BLANK: target}) + a.mark(target) + for tape in counters: + a.rewind(tape, BITS) + if i: + a.op('goto', f'advance{i-1}q{mode}') + else: + a.op('move', OUTER, 1) + a.op('read', OUTER, {ONE: 'record'+str(mode), BLANK: 'finish'}) + for mode in range(4): + a.mark('advanced'+str(mode)) + for tape in counters: + a.rewind(tape, BITS) + a.op('goto', 'record'+str(mode)) + + +def compile_phase(linear=SELECTED_LINEAR, rows=SELECTED_ROWS, + constant=SELECTED_CONSTANT): + """Recipe is finite construction-time data; no runtime size is an argument.""" + m = len(linear) + if not 1 <= m <= len(COUNTERS) or len(rows) != m: + raise ValueError('fixed recipe dimension') + if type(constant) is not int or not 0 <= constant < 4: + raise ValueError('fixed constant phase') + if any(type(x) is not int or not 0 <= x < 4 for x in linear): + raise ValueError('fixed linear phase') + if any(type(x) is not int or not 0 <= x < 1 << m for x in rows): + raise ValueError('fixed quadratic rows') + if any(((rows[i] >> j) ^ (rows[j] >> i)) & 1 + for i in range(m) for j in range(m)): + raise ValueError('symmetric source quadratic matrix') + if any((linear[i] ^ (rows[i] >> i)) & 1 for i in range(m)): + raise ValueError('source diagonal parity') + counters = COUNTERS[:m] + a = Builder() + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, MARK) + a.op('move', tape, 1) + # Supplied local ABI: Gamma(f), Gamma(r), Gamma(P), Gamma(S), Gamma(w). + for target in (COLUMNS, COEFF, OUTER, SPECTATOR, WIDTH): + gamma(a, target) + trace_return(a, HEADER, HTRACE) + initialize(a, counters, constant) + for mode in range(4): + a.mark('record'+str(mode)) + a.op('read', SPECTATOR, {ONE: 'coefficient'+str(mode), BLANK: 'record_end'+str(mode)}) + a.mark('coefficient'+str(mode)) + a.op('read', COEFF, {ONE: 'payload'+str(mode), BLANK: 'coefficient_end'+str(mode)}) + a.mark('payload'+str(mode)) + load_component(a, REAL) + load_component(a, IMAG) + if mode in (2, 3): + negate(a, REAL) + if mode in (1, 2): + negate(a, IMAG) + order = (IMAG, REAL) if mode % 2 else (REAL, IMAG) + for tape in order: + stage_component(a, tape) + a.op('move', COEFF, 1) + a.op('goto', 'coefficient'+str(mode)) + a.mark('coefficient_end'+str(mode)) + a.rewind(COEFF, (ONE,)) + a.op('move', SPECTATOR, 1) + a.op('goto', 'record'+str(mode)) + a.mark('record_end'+str(mode)) + a.rewind(SPECTATOR, (ONE,)) + a.op('goto', f'advance{m-1}q{mode}') + advance(a, counters, linear, rows) + a.mark('finish') + a.op('read', DATA, {BLANK: 'verified', '0': 'reject', ONE: 'reject'}) + a.mark('verified') + trace_return(a, DATA, DTRACE) + a.rewind(OUTPUT, BITS) + a.mark('commit') + a.op('read', OUTPUT, {str(b): 'commit'+str(b) for b in (0, 1)} | {BLANK: 'committed'}) + for bit in ('0', ONE): + a.mark('commit'+bit) + a.op('write', DATA, bit) + a.op('write', OUTPUT, BLANK) + a.op('move', OUTPUT, 1) + a.op('move', DATA, 1) + a.op('write', DTRACE, ONE) + a.op('move', DTRACE, 1) + a.op('goto', 'commit') + a.mark('committed') + trace_return(a, DATA, DTRACE) + a.rewind(OUTPUT, (BLANK,)) + a.rewind(OUTER, (ONE,)) + for tape in (COLUMNS, OUTER, COEFF, SPECTATOR, WIDTH): + clear(a, tape) + for tape in counters: + clear(a, tape, BITS) + for tape in PRIVATE: + a.op('move', tape, -1) + a.op('write', tape, BLANK) + a.op('move', tape, 1) + a.op('halt') + a.mark('reject') + a.op('read', HEADER, {}) + return a.finish((BLANK, '0', ONE, MARK)) diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> j) & 1) << i for i, row in enumerate(matrix)) for j in range(len(matrix))) + + +def inverse(matrix): + n = len(matrix) + rows = [row | (1 << (n+i)) for i, row in enumerate(matrix)] + for j in range(n): + pivot = next((i for i in range(j, n) if rows[i] >> j & 1), None) + require(pivot is not None, 'singular binary chart') + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(n): + if i != j and rows[i] >> j & 1: + rows[i] ^= rows[j] + require([row & ((1 << n)-1) for row in rows] == [1 << i for i in range(n)], 'binary inverse') + return tuple(row >> n for row in rows) + + +def extend(vectors, n): + columns, pivots = [], {} + for value in tuple(vectors) + tuple(1 << i for i in range(n)): + reduced = value + while reduced: + j = reduced.bit_length()-1 + if j not in pivots: + pivots[j] = reduced + columns.append(value) + break + reduced ^= pivots[j] + require(len(columns) == n, 'frame basis extension') + return tuple(columns) + + +def adjoint(circuit): + out = [] + for gate in reversed(circuit): + if gate[0] == 'P': + out.append(('P', inverse(gate[1]))) + elif gate[0] == 'D': + out.append(('D', gate[1], tuple(-a % 4 for a in gate[2]))) + elif gate[0] == 'C': + out.append(('C', gate[1], -gate[2])) + elif gate[0] == 'phase': + out.append(('phase', -gate[1] % 4)) + else: + require(gate[0] == 'X', 'adjoint gate type') + out.append(gate) + return tuple(out) + + +def fourier(rank): + return tuple(('C', 1 << i, 1) for i in range(rank)) + + +def frame(vectors, n): + rank = len(vectors) + if rank == 0: + return () + if rank == n: + return fourier(n) + matrix = transpose(extend(vectors, n)) + columns = transpose(inverse(matrix)) + quadratic = tuple((1 << i) ^ sum(parity(a & b) << j for j, b in enumerate(columns)) for i, a in enumerate(columns)) + diagonal = tuple((row >> i) & 1 for i, row in enumerate(quadratic)) + chart = (('P', matrix), ('D', quadratic, diagonal)) + return adjoint(chart) + fourier(rank) + chart + + +def monomial(record): + matrix = tuple(record['matrix_rows']) + quadratic = tuple(record['quadratic_rows']) + linear = tuple(record['linear_Z4']) + require(transpose(quadratic) == quadratic, 'quadratic symmetry') + require(len(matrix) == len(quadratic) == len(linear) == 9, 'monomial dimension') + require(all(a % 2 == (quadratic[i] >> i) & 1 for i, a in enumerate(linear)), 'diagonal parity') + inverse(matrix) + return (('D', quadratic, linear), ('P', matrix), ('X', record['offset']), ('phase', record['phase'])) + + +def recipe(record): + rank = record['rank'] + require(isinstance(rank, int) and 0 <= rank <= 9, 'child rank') + if rank == 0: + require(record['right'] is None, 'rank zero right factor') + return monomial(record['left']) + return monomial(record['right']) + fourier(rank) + monomial(record['left']) + + +def tableau(circuit, n=9): + rows = [(1 << i, 0, 0) for i in range(n)] + [(0, 1 << i, 0) for i in range(n)] + for gate in circuit: + tag = gate[0] + out = [] + inverse_transpose = transpose(inverse(gate[1])) if tag == 'P' else None + for x, z, phase in rows: + if tag == 'P': + x, z = mul(gate[1], x), mul(inverse_transpose, z) + elif tag == 'X': + phase += 2 * parity(z & gate[1]) + elif tag == 'C': + if parity(z & gate[1]): + x ^= gate[1] + phase += 3 * gate[2] + elif tag == 'D': + quadratic, linear = gate[1:] + phase += sum(linear[i] for i in range(n) if x >> i & 1) + phase += 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(n) if x >> i & 1) + z ^= mul(quadratic, x) + else: + require(tag == 'phase', 'tableau gate type') + out.append((x, z, phase % 4)) + rows = out + return tuple(rows) + + +@lru_cache(maxsize=512) +def action(gate): + if gate[0] == 'P': + return tuple(mul(gate[1], x) for x in range(512)) + require(gate[0] == 'D', 'state action type') + quadratic, linear = gate[1:] + return tuple((sum(linear[i] for i in range(9) if x >> i & 1) + + 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(9) if x >> i & 1)) % 4 for x in range(512)) + + +def rotate(pair, power): + a, b = pair + return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4] + + +def state(circuit, basis=0): + value, denominator = {basis: (1, 0)}, 0 + for gate in circuit: + tag = gate[0] + result = {} + if tag == "C": + direction, sign = gate[1:] + for address, (a, b) in value.items(): + for target, pair in ((address, (a - sign*b, b + sign*a)), + (address ^ direction, (a + sign*b, b - sign*a))): + old = result.get(target, (0, 0)) + result[target] = (old[0] + pair[0], old[1] + pair[1]) + denominator += 1 + else: + for address, pair in value.items(): + if tag == "P": + target = mul(gate[1], address) + elif tag == "X": + target = address ^ gate[1] + else: + target = address + if tag == "D": + pair = rotate(pair, action(gate)[address]) + else: + require(tag == "phase", "Unknown Gaussian state gate") + pair = rotate(pair, gate[1]) + require(target not in result, "A monomial address map is not injective") + result[target] = pair + value = {address: pair for address, pair in result.items() if pair != (0, 0)} + while denominator and all((a | b) % 2 == 0 for a, b in value.values()): + denominator -= 1 + value = {address: (a//2, b//2) for address, (a, b) in value.items()} + return value, denominator + + +def equal(actual, expected, label): + require(tableau(actual) == tableau(expected), label + ": signed Pauli action") + require(state(actual) == state(expected), label + ": exact global phase") + + +def verify(data, certificate): + word = data["word"] + original, clean = data["programs"], data["clean_programs"] + source_recipes = data["recipes"] + residuals = data["residuals"]["recipes"] + native_tags = {"climb", "adapter", "residual_adapter"} + for orientation in ("forward", "backward"): + native = [event for event in clean[orientation] if event[0] in native_tags] + require(native == [event for event in original[orientation] if event[0] in native_tags], + "A retained native event changed") + require(len(native) == 5056, "The retained native event count changed") + frames = [frame(tuple(vectors), 9) for vectors in word["frames"]] + used = {(event[3], event[4]) for program in clean.values() + for event in program if event[0] == "climb"} + children = {(record["old"], record["new"]): record for record in source_recipes["children"]} + require(len(children) == len(source_recipes["children"]) and used <= set(children), + "The retained child recipe coverage is incomplete") + for old, new in sorted(used): + record = children[old, new] + require(record["rank"] == len(word["frames"][new]) - len(word["frames"][old]), + "A retained child has the wrong rank") + equal(recipe(record), adjoint(frames[old]) + frames[new], "Retained child") + endpoints = {(record["role"], record["port"]): record + for record in source_recipes["endpoint_adapters"]} + require(len(endpoints) == len(source_recipes["endpoint_adapters"]) + and set(endpoints) == {(role, p) for role in ("source", "target") for p in range(112)}, + "The endpoint adapter coverage is incomplete") + for (role, port), record in endpoints.items(): + direction = word["ports"][port] + conventional = (("C", direction, 1),) if role == "source" else ( + ("C", direction, -1),) + fourier(9) + index = word["start"][port] if role == "source" else word["final"][112 + port] + require(record["frame"] == index and record["rank"] == 0, "An endpoint frame changed") + equal(recipe(record), adjoint(conventional) + frames[index], "Endpoint adapter") + used_residuals = set() + for program in clean.values(): + for event in program: + if event[0] != "residual_adapter": + continue + _, position, register, entry, *tail = event + terminal = tail[0] if tail else 1 + key = str(entry) if terminal == 1 else str(entry) + ":" + str(terminal) + require(key in residuals and position in ("pre", "post"), "A residual binding changed") + require(entry == word["start"][register] and terminal == word["final"][register], + "A residual endpoint changed") + used_residuals.add(key) + for key in sorted(used_residuals): + record = residuals[key] + equal(recipe(record), adjoint(frames[record["frame"]]) + frames[record.get("terminal", 1)], + "Residual adapter") + records = certificate["input_recipes"] + ports = certificate["compensation_ports"] + require([record["port"] for record in records] == ports and len(records) == 8, + "The eight input recipes changed") + columns = 0 + for item in records: + port, label = item["port"], item["label"] + require(label == word["ports"][port] and item["canonical_start_frame_id"] == word["start"][port], + "An input recipe has the wrong supplier label") + record = item["recipe"] + require(record["rank"] == 1, "An input copy has the wrong child rank") + for side in ("left", "right"): + factor = record[side] + require(factor["quadratic_rows"] == [0] * 9 and factor["linear_Z4"] == [0] * 9 + and factor["offset"] == factor["phase"] == 0, + "An input factor is not an address permutation") + actual, expected = recipe(record), (("C", label, 1),) + equal(actual, expected, "Positive inherited input line") + for basis in range(512): + require(state(actual, basis) == state(expected, basis), "A complete input Gaussian column differs") + columns += 1 + negative = monomial(record["right"]) + (("C", 1, -1),) + monomial(record["left"]) + require(tableau(negative) != tableau(expected) or state(negative) != state(expected), + "An inverse input child was not detected") + phased = actual + (("phase", 1),) + require(tableau(phased) == tableau(actual) and state(phased) != state(expected), + "An input phase-only error was not detected") + return {"status": "PASS_EXACT_INPUT_NATIVE_FRAMES", "retained_native_events_per_orientation": 5056, + "retained_child_recipes": len(used), "endpoint_adapter_recipes": len(endpoints), + "residual_adapter_recipes": len(used_residuals), "new_input_recipes": len(records), + "new_exact_gaussian_columns": columns, "inverse_input_child_controls": len(records), + "phase_only_controls": len(records), "address_permutation_factors": 2 * len(records), + "method": "Independent signed Pauli and exact Gaussian interpretation; no compiler import", + "scope": "Positive inherited input frames before every retained adapter. No recursive hosting claim."} diff --git a/research/borrowed-header-data-only-home/implementation/inputs/core/verify.py b/research/borrowed-header-data-only-home/implementation/inputs/core/verify.py new file mode 100644 index 0000000000..c7f1f5131a --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/inputs/core/verify.py @@ -0,0 +1,209 @@ +"""Source-bound literal uniform-rank Gamma6/HOME numerical replay.""" +from pathlib import Path +import atexit +from hashlib import sha256 +import importlib.util +import json +import random +import shutil +import subprocess +import sys +import tempfile +import time + +HERE = Path(__file__).resolve().parent +_cache = tempfile.TemporaryDirectory(prefix='positive-verify-') +atexit.register(_cache.cleanup) +sys.dont_write_bytecode = True +sys.pycache_prefix = str(Path(_cache.name) / 'required-absent') +import adapter as A +import join as C +from machine import Program, initial, fields, check_retired, Rejected + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def gamma(n): + if n < 1: + raise ValueError('positive Gamma integer') + b = bin(n)[2:] + return '0'*(len(b)-1)+b + + +def header(shape): + return ''.join(gamma(n) for n in shape) + + +def encode(values, width): + if any(not -(1 << (width-1)) <= x < 1 << (width-1) for z in values for x in z): + raise ValueError('oracle signed width') + return ''.join(format(x % (1 << width), '0'+str(width)+'b') for z in values for x in z) + + +def direct(values, rank, *, f=1, omit_last=False): + """Independent natural-address C butterflies on the complete array. + + This oracle indexes every actual active slot bit directly, without + conjugating the first-slot helper or simulating CNOT swaps. + """ + out = list(values) + count = rank-1 if omit_last else rank + for slot in range(count): + for column in range(f): + mask = 1 << (9*f-1-(slot*f+column)) + for i in range(len(out)): + if i & mask: + continue + ar, ai = out[i]; br, bi = out[i | mask] + rows = (ar-ai+br+bi, ar+ai-br+bi, + ar+ai+br-bi, -ar+ai+br+bi) + need(all(x % 2 == 0 for x in rows), 'independent oracle parity') + out[i], out[i | mask] = (rows[0]//2,rows[1]//2),(rows[2]//2,rows[3]//2) + return out + + +def guard_checks(): + from controller_reference import Machine, Tape + records = [] + for rank in range(1,10): + code, _ = C.compile_guard(rank) + cases = [(f, rank*f+delta) for f in (1,2,3,5,16,65,129) + for delta in (-1,0,1) if rank*f+delta > 0] + cases += [(5, 1 << bits) for bits in (63,257,512,1024,4096)] + for f, cutoff in cases: + text = header((f,2,3,2,5,cutoff)) + origins = [11*t-139 for t in range(29)] + tapes = [Tape({o-5:'0',o+1000000:'1'},o) for o in origins] + tapes[0].cells.update({origins[0]+i:b for i,b in enumerate(text)}) + before = [t.cells.copy() for t in tapes] + machine = Machine(code,tapes) + try: + machine.run(5000000); accepted = True + except ValueError as exc: + need(str(exc) == 'invalid scanned symbol', 'unexpected guard rejection') + accepted = False + need(accepted == (rank*f <= cutoff), 'literal rank-times-f cutoff') + need(tapes[0].cells == before[0], 'guard changed header') + if accepted: + need([t.head for t in tapes] == origins and [t.cells for t in tapes] == before, + 'guard private/head retirement') + records.append({'rank':rank,'f':f,'cutoff_bits':cutoff.bit_length(), + 'accepted':accepted,'steps':machine.steps}) + weak, _ = C.compile_guard(3,weak=True) + ts = [Tape({},0) for _ in range(29)] + ts[0] = Tape(dict(enumerate(header((1,1,1,1,8,2)))),0) + Machine(weak,ts).run() + return records + + +def tables(): + result=[] + for rank in range(1,10): + code, alphabet, entries = C.compile_join(rank) + need(alphabet == ('_','0','1','|'), 'core alphabet') + need(not any(op == 'write' and args[0] == C.DATA + for op,*args in code[:entries['commit']]), 'early public core write') + for op,*args in code: + if op in ('read','write','move'): + need(0 <= args[0] < C.TAPES, 'fixed port bound') + if op == 'read': + need(all(0 <= p < len(code) for p in args[1].values()), 'fixed read target') + if op == 'goto': + need(0 <= args[0] < len(code), 'fixed jump target') + if op == 'move': + need(args[1] in (-1,1), 'unit core move') + result.append({'rank':rank,'locations':len(code),'commit':entries['commit'], + 'sha256':sha256(repr(code).encode()).hexdigest()}) + return result + + +def corruption_control(): + with tempfile.TemporaryDirectory(prefix='positive-source-control-') as tmp: + dst = Path(tmp) + for name in ('join.py','SOURCES.json'): + shutil.copy2(HERE/name,dst/name) + for pin in json.loads((HERE/'SOURCES.json').read_text())['files']: + q=dst/pin['local'];q.parent.mkdir(parents=True,exist_ok=True) + shutil.copy2(HERE/pin['local'],q) + q=dst/'reference/rank2/reference/leaf/leaf.py' + q.write_bytes(q.read_bytes()+b'\n# changed actual helper byte\n') + launch=('import sys,tempfile;from pathlib import Path;' + 'd=tempfile.TemporaryDirectory();sys.dont_write_bytecode=True;' + 'sys.pycache_prefix=str(Path(d.name)/"absent");' + 'sys.path.insert(0,'+repr(str(dst))+');import join') + r=subprocess.run([sys.executable,'-I','-B','-c',launch],capture_output=True,text=True) + need(r.returncode != 0 and 'frozen source drift' in r.stderr, 'actual helper drift accepted') + + +def run(): + guard_records = guard_checks() + table_records = tables() + graph, stages = A.compile_home(3) + program = Program(graph) + rng = random.Random(130003) + shape = (1,1,1,1,8,3) + values = [(8*rng.randrange(-1,2),8*rng.randrange(-1,2)) for _ in range(512)] + h = header(shape); data = encode(values,8); bits = h+data + answer = direct(values,3) + expected = h+encode(answer,8) + need(expected != bits and direct(values,2) != answer, 'nontrivial rank-three tensor oracle') + parked = ''.join(str(rng.randrange(2)) for _ in bits) + state = initial((parked,bits),A.TAPES,old_history=3*len(bits)) + old_highs = state.highs.copy() + program.run(state,stop=stages['core_return']) + need(fields(state) == (parked,bits) and state.writes[0] == 0, 'early HOME write before core return') + core_steps = state.steps + program.run(state,start=stages['core_return'],stop=stages['primitive_return']) + need(fields(state) == (parked,bits) and state.writes[0] == 0, 'early HOME write before scatter') + program.run(state,start=stages['primitive_return']) + need(fields(state) == (parked,expected), 'complete literal rank-three output') + need(state.writes[0] == len(bits), 'sole complete owned HOME commit') + check_retired(state) + need(all(x >= y for x,y in zip(state.highs,old_highs)), 'old history refunded') + increment = sum((hi-lo)-(ehi-elo) for lo,hi,elo,ehi in + zip(state.lows,state.highs,state.entry_lows,state.entry_highs)) + need(increment <= 2112*(len(bits)+1), 'complete historical-backing increment') + need(state.steps <= (1 << 24)*(len(data)+len(h)+1)+128*(len(bits)+1), 'complete time bound') + first = {'shape':shape,'E':len(h),'V':len(data),'F':len(bits),'steps':state.steps, + 'core_return_steps':core_steps,'HOME_writes':state.writes[0], + 'visited_increment':increment,'retained_old_guide_high':state.highs[-1], + 'output_sha256':sha256(expected.encode()).hexdigest()} + # Legal packet, wrong joint cutoff: f<=2 but 3*f>2. Public HOME unchanged. + bad = header((1,1,1,1,8,2))+data + rejected = initial(('0'*len(bad),bad),A.TAPES) + before = bytes(rejected.tapes[0]) + try: + program.run(rejected) + except Rejected: + pass + else: + raise ValueError('rank-three joint cutoff accepted') + need(rejected.writes[0] == 0 and bytes(rejected.tapes[0]) == before, 'cutoff changed public HOME') + # Actually execute omitted-third-C mutant; same ABI returns a different tensor. + wrong_graph,_ = A.compile_home(3,mutation='omit_last_C') + wrong = initial((parked,bits),A.TAPES) + Program(wrong_graph).run(wrong) + need(fields(wrong) == (parked,h+encode(direct(values,2),8)) and fields(wrong)[1] != expected, + 'omitted third active slot control') + check_retired(wrong) + corruption_control() + return {'marker':'PASS_LITERAL_GENERIC_POSITIVE_HOME','tapes':A.TAPES,'core_tapes':C.TAPES, + 'rank_three':first,'tables':table_records,'guard_cases':guard_records, + 'cutoff_rejection_steps':rejected.steps,'omitted_child_steps':wrong.steps, + 'controls':['joint cutoff versus weak f cutoff','actual omitted third C', + 'actual retained source corruption','no early original-owner write'], + 'scope':'fixed-rank positive central direct leaf only; no surrounding monomials/caller/nonleaf rate'} + + +if __name__ == '__main__': + start = time.monotonic() + result = run() + if '--write' in sys.argv: + (HERE/'RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + elif (HERE/'RESULT.json').exists(): + need(json.loads((HERE/'RESULT.json').read_text()) == json.loads(json.dumps(result)), 'receipt changed') + print(json.dumps(result,sort_keys=True)) + print('elapsed_seconds',round(time.monotonic()-start,3)) diff --git a/research/borrowed-header-data-only-home/implementation/machine.py b/research/borrowed-header-data-only-home/implementation/machine.py new file mode 100644 index 0000000000..fcd4ac01f0 --- /dev/null +++ b/research/borrowed-header-data-only-home/implementation/machine.py @@ -0,0 +1,129 @@ +"""Dense interpreter of literal Graphs; observers never drive control. Apache-2.0.""" +from dataclasses import dataclass +SYMBOLS={s:i for i,s in enumerate('_01^|$')} + + +class Rejected(ValueError):pass +class MonitorViolation(ValueError):pass + + +@dataclass +class State: + tapes:list + heads:list + origins:list + lows:list + highs:list + entry_lows:list + entry_highs:list + writes:list + steps:int=0 + + def clone(self): + return State([bytearray(t) for t in self.tapes],self.heads.copy(),self.origins.copy(), + self.lows.copy(),self.highs.copy(),self.entry_lows.copy(),self.entry_highs.copy(), + self.writes.copy(),self.steps) + + +def initial(payloads,tape_count,*,old_history=0): + if len(payloads)!=2 or len(payloads[0])!=len(payloads[1]) or not payloads[0]: + raise ValueError('two complete same-F source homes') + f=len(payloads[0]);capacity=16*(f+128)+256 + origins=[17+(t%7) for t in range(tape_count)] + text='^'+'|'.join(payloads)+'|$' + tapes=[bytearray(capacity) for _ in range(tape_count)] + for tape,o in zip(tapes,origins): + tape[o]=SYMBOLS['^'];tape[o-3:o]=bytes([2,1,4]);tape[-3:]=bytes([1,4,2]) + o=origins[0];tapes[0][o:o+len(text)]=bytes(SYMBOLS[s] for s in text) + lows=origins.copy();highs=origins.copy();highs[0]=o+len(text)-1 + if old_history:highs[-1]=origins[-1]+old_history + return State(tapes,origins.copy(),origins,lows.copy(),highs.copy(),lows,highs,[0]*tape_count) + + +class Program: + def __init__(self,graph): + names=list(graph.rules);self.labels={name:i for i,name in enumerate(names)} + self.labels['HALT']=-1;self.start=self.labels[graph.start];self.rows=[] + for name in names: + rules=[(tuple((t,SYMBOLS[s]) for t,s in r.tests), + tuple((t,SYMBOLS[s]) for t,s in r.writes),r.moves, + self.labels[r.target]) for r in graph.rules[name]] + if rules and all(len(r[0])==1 and not r[1] and not r[2] for r in rules) and len({r[0][0][0] for r in rules})==1: + branch=[-2]*6 + for r in rules:branch[r[0][0][1]]=r[3] + self.rows.append((0,rules[0][0][0][0],branch)) + elif len(rules)==1 and not rules[0][0]: + _,writes,moves,nxt=rules[0] + if len(writes)==1 and not moves:self.rows.append((1,writes[0][0],(writes[0][1],nxt))) + elif len(moves)==1 and not writes:self.rows.append((2,moves[0][0],(moves[0][1],nxt))) + elif not moves and not writes:self.rows.append((3,nxt,None)) + else:self.rows.append((4,rules,None)) + else:self.rows.append((4,rules,None)) + + def run(self,state,*,start=None,stop=None,budget=100000000): + pc=self.start if start is None else self.labels[start] + stop_pc=None if stop is None else self.labels[stop] + rows=self.rows;tapes=state.tapes;heads=state.heads + lows=state.lows;highs=state.highs;writes=state.writes + while pc!=-1 and pc!=stop_pc: + op,t,arg=rows[pc] + if op==0: + pc=arg[tapes[t][heads[t]]] + if pc==-2:raise Rejected('literal scanned-symbol rejection') + elif op==1: + value,pc=arg + if heads[t]==state.origins[t] and value!=3: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + elif op==2: + delta,pc=arg + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t]budget:raise ValueError('finite execution budget') + return state + + def _general(self,state,rules): + tapes=state.tapes;heads=state.heads;lows=state.lows;highs=state.highs;writes=state.writes + found=None + for rule in rules: + if all(tapes[t][heads[t]]==symbol for t,symbol in rule[0]): + if found is not None:raise ValueError('nondeterministic emitted table') + found=rule + if found is None:raise Rejected('literal scanned-symbol rejection') + for t,value in found[1]: + if heads[t]==state.origins[t] and value!=SYMBOLS['^']: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + for t,delta in found[2]: + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t]=old for hi,old in zip(s.highs,s.entry_highs)),'old backing refund') + V,E1,E2=len(data),len(short),len(large) + need((E1,E2,V)==(10,268,6144),'unequal-E full fixture') + need(s.steps<=2*((1<<24)*(V+E2+1)+256*(V+1))+256*(V+2),'complete time') + increment=sum((hi-lo)-(eh-el) for lo,hi,el,eh in zip(s.lows,s.highs,s.entry_lows,s.entry_highs)) + need(increment<=2*2112*(V+E2+1)+16*(V+2),'history increment') + rejected=[];controls=[] + for name,g,bits in [('joint_cutoff',A.compile_home(2)[0],data), + ('short_DATA',A.compile_home(1)[0],data[:-1]), + ('late_nonintegral',A.compile_home(1)[0],encode([(0,0)]*255+[(1,0)]+[(0,0)]*256))]: + bad=setup(bits,('01'*len(bits))[:len(bits)],{3:short});saved=bytes(bad.tapes[0]);savedh=bytes(bad.tapes[3]) + try:Program(g).run(bad) + except Rejected: + need(bad.writes[0]==0 and bytes(bad.tapes[0])==saved,'rejection HOME mutation') + need(bytes(bad.tapes[3])==savedh,'rejection header mutation') + else:raise ValueError('invalid boundary accepted '+name) + rejected.append({'case':name,'steps':bad.steps,'HOME_writes':bad.writes[0]}) + g,t=A.compile_home(1,mutation='drop_return_bit');bad=core_done.clone() + try:Program(g).run(bad,start=t[0]['core_return']) + except Rejected:need(bad.writes[0]==0 and fields(bad)==(parked,data),'late mismatch scattered HOME') + else:raise ValueError('dropped output bit scattered') + controls.append('late_return_extent_mismatch_before_HOME_scatter') + g,t=A.compile_home(1,selected=0);bad=ready.clone();Program(g).run(bad,start=t[0]['primitive_return']) + need(fields(bad)!=(parked,answer1),'wrong HOME escaped');controls.append('wrong_HOME_scatter') + g,t=A.compile_home(1,mutation='skip_return');bad=core_done.clone();Program(g).run(bad,start=t[0]['core_return']) + need(fields(bad)!=(parked,answer1),'skipped private return escaped');controls.append('skipped_private_return') + g,_=A.compile_home(1,mutation='guard_offset');bad=setup(data,parked,{3:short}) + try:Program(g).run(bad) + except MonitorViolation:pass + else:raise ValueError('wrong guard offset escaped test monitor') + controls.append('test_monitor_detects_guard_over_B_origin') + return {'marker':'PASS_BORROWED_HEADER_DATA_HOME','rank':1,'V_HOME':V,'header_lengths':[E1,E2], + 'cutoff_bit_lengths':[1,130],'tapes_single_header':34,'tapes_two_header_fixture':35, + 'core_locations':len(A.core(1)),'two_call_graph_states':len(graph.rules),'total_steps':s.steps, + 'first_commit_and_second_gather_steps':first_steps,'HOME_writes':s.writes[0], + 'borrowed_HEADER_writes':[s.writes[3],s.writes[34]],'history_increment_measured':increment, + 'entry_head_spans':list(zip(s.entry_lows,s.entry_highs)),'final_head_spans':list(zip(s.lows,s.highs)), + 'history_scope':'Entry includes supplied/exterior storage and prior larger history; no erasure refund.', + 'input_sha256':sha256(data.encode()).hexdigest(),'first_output_sha256':sha256(answer1.encode()).hexdigest(), + 'second_output_sha256':sha256(answer2.encode()).hexdigest(),'parked_sha256':sha256(parked.encode()).hexdigest(), + 'rejections':rejected,'fault_controls':controls, + 'reuse_boundary':'Both distinct immutable headers are supplied at initial entry; same HOME and private owners/origins reused. No host header replacement counted as implementation.', + 'scope':'Already-packed supplied Gamma6/native view; no producer, view packing, cutoff derivation, all-MOVE/caller or kappa claim.'} +if __name__=='__main__': + r=json.loads(json.dumps(run()));dest=HERE/'RESULT.json' + if '--write' in sys.argv:dest.write_text(json.dumps(r,indent=2,sort_keys=True)+'\n') + else:need(r==json.loads(dest.read_text()),'receipt drift') + print('PASS_BORROWED_HEADER_DATA_HOME: immutable headers, complete DATA-only returns and controls.') diff --git a/research/borrowed-header-data-only-home/review/interface/PORTABILITY.json b/research/borrowed-header-data-only-home/review/interface/PORTABILITY.json new file mode 100644 index 0000000000..8c8aab6c9a --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/PORTABILITY.json @@ -0,0 +1,11 @@ +{ + "original_manifest_sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f", + "original_checker_sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590", + "portable_checker_sha256": "d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb", + "edits": [ + "Replace hardcoded SUBJECT with required implementation-directory argv.", + "Replace unconditional receipt write with read-only scientific receipt comparison, excluding only elapsed_seconds; print scientific result." + ], + "unchanged": "All instruction comparison, sparse execution, numerical oracle, history/cleanup and extent assertions. Original complete review package retained under original/.", + "subject_unchanged": true +} diff --git a/research/borrowed-header-data-only-home/review/interface/RESULT.json b/research/borrowed-header-data-only-home/review/interface/RESULT.json new file mode 100644 index 0000000000..1e9e07cdfe --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/RESULT.json @@ -0,0 +1,33 @@ +{ + "marker": "PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW", + "embedded_instructions_checked": 1373214, + "packet": { + "rank": 2, + "V": 6144, + "header_lengths": [ + 12, + 12308 + ], + "header_sequence": [ + 3, + 34, + 3 + ], + "steps": 18592251, + "HOME_writes": 18432, + "header_writes": [ + 0, + 0 + ], + "returned_extent_faults": [ + "short", + "long" + ], + "reachable_header_writes": 0, + "unreachable_header_writes": 8, + "signed_origins": true, + "final_output_sha256": "a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25" + }, + "subject_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "elapsed_seconds": 24.55 +} diff --git a/research/borrowed-header-data-only-home/review/interface/REVIEW.md b/research/borrowed-header-data-only-home/review/interface/REVIEW.md new file mode 100644 index 0000000000..52c6274e09 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/REVIEW.md @@ -0,0 +1,106 @@ +# Read-only review: borrowed HEADER, DATA-only HOME + +**PASS for the stated supplied-entry interface. No correctness or charging +defect was found.** This is independent AI source/proof review plus a newly +written sparse interpreter/checker, not human or proof-kernel acceptance. +The subject was not modified. + +Subject: worker-b/research/borrowed-header-data-home, frozen manifest SHA256 +`0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7`. +Adapter SHA256182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14; +proof667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744. +Canonical context remains e54523517d0f03e58352e647c403a5af3e525a57. + +## Exact origin and ownership check + +Native port0 is borrowed HEADER h; t>=1 maps injectively to3+t. The +borrowed first Gamma bit is B-relative1, while DATA4 and private5..33 start +at2. Their native-private guards therefore occupy blank B-cell1 rather +than permanent^0. HEADER has no native-private guard: its trace returns +exactly to first bit1 and the wrapper moves it once left to B-origin0. +The immutable core never writes HEADER. I compared the emitted injection +against direct absolute-PC/port expectations for all ranks1..9 and h3/34, +checking **1,373,214 retained instructions**. No instruction differs. + +The declared entry is execution_start after reservation. B1's old reservation +prefix writes tape3 and is incompatible with a borrowed HEADER there. That +prefix remains serialized but is unreachable. My separate reachability +walk found0 reachable header writes and8 unreachable header writes in the +three-call review graph. The entry boundary is therefore material and is +correctly stated. Header production, initial reservation/marker provisioning +and source placement are supplied/paid rather than inferred. + +## DATA extent, scatter and restoration + +Incoming DATA is copied to a blank native owner until the operand delimiter. +All headers remain separate; no E header bits become HOME payload. Return +simultaneously tests old operand/new DATA binary symbols, copies one new bit, +erases it and advances both. Success requires operand| and native blank +together. Short and long returned extents cannot pass or overwrite the +delimiter. Rejection can dirty the private operand; original HOME remains +unchanged because B1 scatter is reached only after complete return/cleanup. + +Every native-private head returns from2 to0 after its core cleanup. DATA's +blank-body rewind stops at permanent^0. HEADER returns from1 to0. B1 then +scatters to the immutable same HOME and retires its operand. The core's full +9f geometry, positive orientation, joint rho*f cutoff and actual numerical +prefix promises remain inherited. Failure cleanup/retry and universal +malformed-input validation are not claimed and are not required here. + +## Complete bill and historical backing + +The healthy prefix consists of60 native head moves, one joint advance, +V clone rules and terminal test, a V+3 DATA rewind, two DATA reposition +moves and a V+2 operand rewind: exactly3V+69. The suffix has one advance, +V paired installs and terminal test, V+2/V+3 rewinds,58 private-return moves +and one header return:3V+66. Thus6V+135 is below the author's6V+160 and +256(V+1) envelopes. Core halt-to-continuation remains one counted step, +so no return instruction or body pass is hidden. Complete B1 work/setup +remain separate as stated in the proof. + +Before native entry, DATA newly visits at most V+2 cells and29 private +owners visit two cells each. HEADER/operand storage is supplied at entry. +The suffix stays within those or core windows. The additional64(V+1) +wrapper backing is conservative; adding unchanged core2048(V+E+1) gives +2112(V+E+1). Old/opaque storage stays in K_entry. Sparse cell counts or +largest live bodies are not substituted for historical backing. E is fully +charged by the core and can exceed V; HOME extent still equals V. + +## Executable evidence + +Every subject checksum passed before replay. The frozen registered normal +and -O commands both passed without --write. My own checker does not import +the subject machine.py or verify.py. It uses signed distinct origins, +dictionary tapes and direct Graph-rule execution, plus a natural-address +two-axis Gaussian oracle independent of slot-swap routing. + +The fresh rho2 fixture has V6144 and two headers of lengths12 and12308, +so the long header is larger than DATA. Both headers exist from initial +entry. A fixed header sequence3,34,3 runs three services on the same HOME, +native/private owners and origins, without host header replacement. It +passes exact intermediate/final outputs, native HEADER+1/private+2 head +checks, private cleanup before scatter, all final heads/private/exteriors, +zero header writes and retained earlier/larger histories. It takes18592251 +transitions and18432 final HOME writes. Final output SHA256 is +a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25. + +Independent short/long returned-field faults injected at completed native +return both reject before HOME scatter and preserve both headers/public +HOME bytes. These are extent-check controls outside the healthy core +contract, not new claims about numerical failure cleanup. The current +checker passes with -O, uses explicit exceptions and authenticates source +before retained imports using a fresh absent bytecode prefix. + +Subject FREEZE/adapter/proof/RESULT hashes were unchanged after testing. +The registered guard-origin monitor is correctly described as a test +observer, not compiled protection. No scope expansion is needed. + +## Retained limitations + +The result starts with an already-packed DATA-only field and a genuinely +distinct immutable Gamma6 header. It does not convert the actual nine-Gamma +root descriptor, produce a native view/common grid, derive cutoff policy, +admit a source occurrence/caller, prove a faster nonleaf tariff or change +kappa. Default h3 uses34 tapes; the h3/h34 fixture uses35 fixed public/private +owners. Other offline header-owner choices require their actual owners to +be supplied. These are interface boundaries, not defects in this package. diff --git a/research/borrowed-header-data-only-home/review/interface/check_review.py b/research/borrowed-header-data-only-home/review/interface/check_review.py new file mode 100644 index 0000000000..222cd7a818 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/check_review.py @@ -0,0 +1,171 @@ +"""Read-only independent sparse-Graph review of B's frozen adapter.""" +from pathlib import Path +from hashlib import sha256 +import atexit,copy,importlib.util,json,random,sys,tempfile,time +HERE=Path(__file__).resolve().parent +if len(sys.argv)!=2:raise ValueError('supply the implementation directory') +SUBJECT=Path(sys.argv[1]).resolve() +cache=tempfile.TemporaryDirectory(prefix='borrow-review-');atexit.register(cache.cleanup) +sys.dont_write_bytecode=True;sys.pycache_prefix=str(Path(cache.name)/'absent') + + +def need(ok,label): + if not ok:raise ValueError(label) + + +need(sha256((SUBJECT/'FREEZE.json').read_bytes()).hexdigest()=='0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7','subject freeze') +freeze=json.loads((SUBJECT/'FREEZE.json').read_text()) +for pin in freeze['files']: + raw=(SUBJECT/pin['path']).read_bytes();need(len(raw)==pin['bytes'] and sha256(raw).hexdigest()==pin['sha256'],'frozen subject bytes') +spec=importlib.util.spec_from_file_location('review_borrowed_adapter',SUBJECT/'adapter.py') +A=importlib.util.module_from_spec(spec);sys.modules[spec.name]=A;spec.loader.exec_module(A) + + +class Capture: + def __init__(self):self.rules={};self.count=0 + def state(self,name): + n=self.count;self.count+=1;self.rules[n]=[];return n + def add(self,state,target,tests=(),writes=(),moves=()): + self.rules[state].append((target,tuple(tests),tuple(writes),tuple(moves))) + + +def relocation(): + checked=0 + for rank in range(1,10): + code=A.core(rank) + for header in (3,34): + capture=Capture();need(A.embed(capture,code,-1,header)==0,'embedded start') + for pc,(op,*args) in enumerate(code): + port=lambda t:header if t==0 else 3+t + nxt=pc+1 if pc+10,'reservation-entry boundary control') + self.names=list(g.rules);self.loc={n:i for i,n in enumerate(self.names)};self.loc['HALT']=-1 + self.rows=[[(self.loc[r.target],r.tests,r.writes,r.moves) for r in g.rules[n]] for n in self.names] + self.pc=self.loc[g.start];self.origins=[19*t-401 for t in range(35)];self.heads=self.origins.copy() + self.tapes=[{o:'^',o-7:'1',o+1000000:'0'} for o in self.origins] + for t,text in [(0,'^'+payloads[0]+'|'+payloads[1]+'|$')]+[(t,'^'+h+'|$101') for t,h in headers.items()]: + self.tapes[t].update({self.origins[t]+i:s for i,s in enumerate(text)}) + self.low=self.origins.copy();self.high=self.origins.copy();self.high[33]+=10*len(payloads[0]) + self.writes=[0]*35;self.steps=0 + def run(self,stop=None): + target=None if stop is None else self.loc[stop] + while self.pc!=-1 and self.pc!=target: + matches=[] + for rule in self.rows[self.pc]: + if all(self.tapes[t].get(self.heads[t],'_')==s for t,s in rule[1]):matches.append(rule) + if not matches:raise Rejected('no matching local-symbol rule') + need(len(matches)==1,'nondeterministic Graph') + nxt,_,writes,moves=matches[0] + for t,s in writes: + if s=='_':self.tapes[t].pop(self.heads[t],None) + else:self.tapes[t][self.heads[t]]=s + self.writes[t]+=1 + for t,d in moves: + need(d in (-1,0,1),'nonunit Graph movement');self.heads[t]+=d + self.low[t]=min(self.low[t],self.heads[t]);self.high[t]=max(self.high[t],self.heads[t]) + self.pc=nxt;self.steps+=1 + need(self.steps<100000000,'review execution cap') + def fields(self): + o=self.origins[0];t=self.tapes[0];pos=o+1;out=[] + for _ in range(2): + bits=[] + while t.get(pos) in ('0','1'):bits.append(t[pos]);pos+=1 + need(t.get(pos)=='|','HOME delimiter');pos+=1;out.append(''.join(bits)) + need(t.get(pos)=='$','HOME endpoint');return tuple(out) + + +def gamma(n): + b=bin(n)[2:];return '0'*(len(b)-1)+b +def header(shape):return ''.join(gamma(x) for x in shape) +def encode(values):return ''.join(format(x%64,'06b') for z in values for x in z) +def operator(values): + out=list(values) + for mask in (256,128): + for i in range(512): + if i&mask:continue + a,b=out[i];c,d=out[i|mask];rows=(a-b+c+d,a+b-c+d,a+b+c-d,-a+b+c+d) + need(all(x%2==0 for x in rows),'oracle exact halves') + out[i],out[i|mask]=(rows[0]//2,rows[1]//2),(rows[2]//2,rows[3]//2) + return out + + +def physical(): + rng=random.Random(8032026);values=[(4*rng.randrange(-1,2),4*rng.randrange(-1,2)) for _ in range(512)] + data=encode(values);parked=''.join(str(rng.randrange(2)) for _ in data);v=len(data) + hs={3:header((1,1,1,1,6,2)),34:header((1,1,1,1,6,1<<(v+5)))} + need(len(hs[34])>v,'genuinely E larger than DATA') + graph,stages=A.compile_home(2,header_tapes=(3,34,3));cpu=Sparse(graph,(parked,data),hs) + before=copy.deepcopy(cpu.tapes);old_high=cpu.high.copy();answers=[];snapshot=None + for event in range(3): + old_data=data;values=operator(values);data=encode(values);answers.append(data) + cpu.run(stages[event]['core_return']) + need(cpu.fields()==(parked,old_data),'HOME wrote before native return') + need(cpu.heads[3 if event!=1 else 34]==cpu.origins[3 if event!=1 else 34]+1,'borrowed origin+1') + need(all(cpu.heads[t]==cpu.origins[t]+2 for t in range(4,34)),'native origin+2') + if event==0:snapshot=copy.deepcopy(cpu) + cpu.run(stages[event]['primitive_return']) + need(cpu.fields()==(parked,old_data),'HOME wrote during private install') + need(all(cpu.tapes[t]==before[t] for t in range(4,34)),'native private retirement') + need(cpu.heads==cpu.origins,'all heads before scatter') + cpu.run(None if event==2 else stages[event+1]['adapter_entry']) + need(cpu.fields()==(parked,data),'exact rank2 DATA-only scatter') + need(all(a>=b for a,b in zip(cpu.high,old_high)),'historical backing reduced') + old_high=cpu.high.copy() + need(cpu.writes[0]==3*v and cpu.writes[3]==cpu.writes[34]==0,'public write counts') + need(cpu.heads==cpu.origins,'final heads') + need(all(cpu.tapes[t]==before[t] for t in range(1,35)),'final private/header/exterior equality') + rejected=[] + for kind in ('short','long'): + bad=copy.deepcopy(snapshot);end=bad.origins[4]+2+v + if kind=='short':bad.tapes[4].pop(end-1) + else:bad.tapes[4][end]='1' + try:bad.run() + except Rejected:pass + else:raise ValueError('returned extent mismatch accepted') + need(bad.writes[0]==0,'mismatch HOME write') + need(bad.tapes[0]==snapshot.tapes[0] and bad.tapes[3]==snapshot.tapes[3] and bad.tapes[34]==snapshot.tapes[34], + 'mismatch public bytes changed') + rejected.append(kind) + return {'rank':2,'V':v,'header_lengths':[len(hs[3]),len(hs[34])], + 'header_sequence':[3,34,3],'steps':cpu.steps,'HOME_writes':cpu.writes[0], + 'header_writes':[cpu.writes[3],cpu.writes[34]],'returned_extent_faults':rejected, + 'reachable_header_writes':cpu.reachable_header_writes, + 'unreachable_header_writes':cpu.unreachable_header_writes, + 'signed_origins':True,'final_output_sha256':sha256(data.encode()).hexdigest()} + + +if __name__=='__main__': + started=time.monotonic();count=relocation();packet=physical() + result={'marker':'PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW','embedded_instructions_checked':count, + 'packet':packet,'subject_freeze_sha256':sha256((SUBJECT/'FREEZE.json').read_bytes()).hexdigest(), + 'elapsed_seconds':round(time.monotonic()-started,3)} + expected=json.loads((HERE/'RESULT.json').read_text()) + scientific={k:v for k,v in result.items() if k!='elapsed_seconds'} + need(scientific=={k:v for k,v in expected.items() if k!='elapsed_seconds'},'independent scientific receipt drift') + print(json.dumps(scientific,sort_keys=True)) diff --git a/research/borrowed-header-data-only-home/review/interface/original/CHECKPOINT.md b/research/borrowed-header-data-only-home/review/interface/original/CHECKPOINT.md new file mode 100644 index 0000000000..a7e11ed70a --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/original/CHECKPOINT.md @@ -0,0 +1,17 @@ +Read-only cross-review assigned after MOVE24476 freeze handoff, 2026-11-13. +Deadline14:40 UTC. Await B's exact borrowed-header-data-home freeze before +reading the evolving package. No edits to B's package or any frozen source. + +Required scope: immutable generic positive core; borrowed HEADER origin+1 +versus native private origins+2; DATA-only exact extent; borrowed/source +header preservation; all heads/private guards/history; mismatch rejection +and repeated calls. Review artifacts/checkers, if needed, remain isolated +here. No scientific graph implementation or scope expansion is authorized. + +Completed14:37 UTC: subject freeze authenticated and unchanged; registered +normal/-O commands pass. Independent direct-PC injection checks1373214 +instructions across ranks1..9/header3,34. Fresh sparse CPU at signed distinct +origins passes3 rho2 calls with header sequence3,34,3 and E12/12308>V6144, +both returned-extent mismatch directions, all cleanup/public safety/history. +Review verdict PASS for the stated supplied-entry contract; no defect found. +Exact source pins, limitations and charging derivation are in REVIEW.md. diff --git a/research/borrowed-header-data-only-home/review/interface/original/MANIFEST.json b/research/borrowed-header-data-only-home/review/interface/original/MANIFEST.json new file mode 100644 index 0000000000..3147be66ec --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/original/MANIFEST.json @@ -0,0 +1,27 @@ +{ + "status": "FROZEN_REVIEW", + "subject_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "files": [ + { + "path": "CHECKPOINT.md", + "bytes": 1125, + "sha256": "76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495" + }, + { + "path": "RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "check_review.py", + "bytes": 9157, + "sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590" + } + ], + "verdict": "PASS scoped supplied-entry borrowed HEADER/DATA-only HOME; no subject mutation" +} diff --git a/research/borrowed-header-data-only-home/review/interface/original/RESULT.json b/research/borrowed-header-data-only-home/review/interface/original/RESULT.json new file mode 100644 index 0000000000..1e9e07cdfe --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/original/RESULT.json @@ -0,0 +1,33 @@ +{ + "marker": "PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW", + "embedded_instructions_checked": 1373214, + "packet": { + "rank": 2, + "V": 6144, + "header_lengths": [ + 12, + 12308 + ], + "header_sequence": [ + 3, + 34, + 3 + ], + "steps": 18592251, + "HOME_writes": 18432, + "header_writes": [ + 0, + 0 + ], + "returned_extent_faults": [ + "short", + "long" + ], + "reachable_header_writes": 0, + "unreachable_header_writes": 8, + "signed_origins": true, + "final_output_sha256": "a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25" + }, + "subject_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "elapsed_seconds": 24.55 +} diff --git a/research/borrowed-header-data-only-home/review/interface/original/REVIEW.md b/research/borrowed-header-data-only-home/review/interface/original/REVIEW.md new file mode 100644 index 0000000000..52c6274e09 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/original/REVIEW.md @@ -0,0 +1,106 @@ +# Read-only review: borrowed HEADER, DATA-only HOME + +**PASS for the stated supplied-entry interface. No correctness or charging +defect was found.** This is independent AI source/proof review plus a newly +written sparse interpreter/checker, not human or proof-kernel acceptance. +The subject was not modified. + +Subject: worker-b/research/borrowed-header-data-home, frozen manifest SHA256 +`0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7`. +Adapter SHA256182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14; +proof667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744. +Canonical context remains e54523517d0f03e58352e647c403a5af3e525a57. + +## Exact origin and ownership check + +Native port0 is borrowed HEADER h; t>=1 maps injectively to3+t. The +borrowed first Gamma bit is B-relative1, while DATA4 and private5..33 start +at2. Their native-private guards therefore occupy blank B-cell1 rather +than permanent^0. HEADER has no native-private guard: its trace returns +exactly to first bit1 and the wrapper moves it once left to B-origin0. +The immutable core never writes HEADER. I compared the emitted injection +against direct absolute-PC/port expectations for all ranks1..9 and h3/34, +checking **1,373,214 retained instructions**. No instruction differs. + +The declared entry is execution_start after reservation. B1's old reservation +prefix writes tape3 and is incompatible with a borrowed HEADER there. That +prefix remains serialized but is unreachable. My separate reachability +walk found0 reachable header writes and8 unreachable header writes in the +three-call review graph. The entry boundary is therefore material and is +correctly stated. Header production, initial reservation/marker provisioning +and source placement are supplied/paid rather than inferred. + +## DATA extent, scatter and restoration + +Incoming DATA is copied to a blank native owner until the operand delimiter. +All headers remain separate; no E header bits become HOME payload. Return +simultaneously tests old operand/new DATA binary symbols, copies one new bit, +erases it and advances both. Success requires operand| and native blank +together. Short and long returned extents cannot pass or overwrite the +delimiter. Rejection can dirty the private operand; original HOME remains +unchanged because B1 scatter is reached only after complete return/cleanup. + +Every native-private head returns from2 to0 after its core cleanup. DATA's +blank-body rewind stops at permanent^0. HEADER returns from1 to0. B1 then +scatters to the immutable same HOME and retires its operand. The core's full +9f geometry, positive orientation, joint rho*f cutoff and actual numerical +prefix promises remain inherited. Failure cleanup/retry and universal +malformed-input validation are not claimed and are not required here. + +## Complete bill and historical backing + +The healthy prefix consists of60 native head moves, one joint advance, +V clone rules and terminal test, a V+3 DATA rewind, two DATA reposition +moves and a V+2 operand rewind: exactly3V+69. The suffix has one advance, +V paired installs and terminal test, V+2/V+3 rewinds,58 private-return moves +and one header return:3V+66. Thus6V+135 is below the author's6V+160 and +256(V+1) envelopes. Core halt-to-continuation remains one counted step, +so no return instruction or body pass is hidden. Complete B1 work/setup +remain separate as stated in the proof. + +Before native entry, DATA newly visits at most V+2 cells and29 private +owners visit two cells each. HEADER/operand storage is supplied at entry. +The suffix stays within those or core windows. The additional64(V+1) +wrapper backing is conservative; adding unchanged core2048(V+E+1) gives +2112(V+E+1). Old/opaque storage stays in K_entry. Sparse cell counts or +largest live bodies are not substituted for historical backing. E is fully +charged by the core and can exceed V; HOME extent still equals V. + +## Executable evidence + +Every subject checksum passed before replay. The frozen registered normal +and -O commands both passed without --write. My own checker does not import +the subject machine.py or verify.py. It uses signed distinct origins, +dictionary tapes and direct Graph-rule execution, plus a natural-address +two-axis Gaussian oracle independent of slot-swap routing. + +The fresh rho2 fixture has V6144 and two headers of lengths12 and12308, +so the long header is larger than DATA. Both headers exist from initial +entry. A fixed header sequence3,34,3 runs three services on the same HOME, +native/private owners and origins, without host header replacement. It +passes exact intermediate/final outputs, native HEADER+1/private+2 head +checks, private cleanup before scatter, all final heads/private/exteriors, +zero header writes and retained earlier/larger histories. It takes18592251 +transitions and18432 final HOME writes. Final output SHA256 is +a31e6b6d247ad25c531b049ad59069fa0616811f47189aa3568f775509339f25. + +Independent short/long returned-field faults injected at completed native +return both reject before HOME scatter and preserve both headers/public +HOME bytes. These are extent-check controls outside the healthy core +contract, not new claims about numerical failure cleanup. The current +checker passes with -O, uses explicit exceptions and authenticates source +before retained imports using a fresh absent bytecode prefix. + +Subject FREEZE/adapter/proof/RESULT hashes were unchanged after testing. +The registered guard-origin monitor is correctly described as a test +observer, not compiled protection. No scope expansion is needed. + +## Retained limitations + +The result starts with an already-packed DATA-only field and a genuinely +distinct immutable Gamma6 header. It does not convert the actual nine-Gamma +root descriptor, produce a native view/common grid, derive cutoff policy, +admit a source occurrence/caller, prove a faster nonleaf tariff or change +kappa. Default h3 uses34 tapes; the h3/h34 fixture uses35 fixed public/private +owners. Other offline header-owner choices require their actual owners to +be supplied. These are interface boundaries, not defects in this package. diff --git a/research/borrowed-header-data-only-home/review/interface/original/check_review.py b/research/borrowed-header-data-only-home/review/interface/original/check_review.py new file mode 100644 index 0000000000..bc0a231be3 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/interface/original/check_review.py @@ -0,0 +1,167 @@ +"""Read-only independent sparse-Graph review of B's frozen adapter.""" +from pathlib import Path +from hashlib import sha256 +import atexit,copy,importlib.util,json,random,sys,tempfile,time +HERE=Path(__file__).resolve().parent +SUBJECT=Path('/workspace/scratch/92c9920affc2/worker-b/research/borrowed-header-data-home') +cache=tempfile.TemporaryDirectory(prefix='borrow-review-');atexit.register(cache.cleanup) +sys.dont_write_bytecode=True;sys.pycache_prefix=str(Path(cache.name)/'absent') + + +def need(ok,label): + if not ok:raise ValueError(label) + + +need(sha256((SUBJECT/'FREEZE.json').read_bytes()).hexdigest()=='0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7','subject freeze') +freeze=json.loads((SUBJECT/'FREEZE.json').read_text()) +for pin in freeze['files']: + raw=(SUBJECT/pin['path']).read_bytes();need(len(raw)==pin['bytes'] and sha256(raw).hexdigest()==pin['sha256'],'frozen subject bytes') +spec=importlib.util.spec_from_file_location('review_borrowed_adapter',SUBJECT/'adapter.py') +A=importlib.util.module_from_spec(spec);sys.modules[spec.name]=A;spec.loader.exec_module(A) + + +class Capture: + def __init__(self):self.rules={};self.count=0 + def state(self,name): + n=self.count;self.count+=1;self.rules[n]=[];return n + def add(self,state,target,tests=(),writes=(),moves=()): + self.rules[state].append((target,tuple(tests),tuple(writes),tuple(moves))) + + +def relocation(): + checked=0 + for rank in range(1,10): + code=A.core(rank) + for header in (3,34): + capture=Capture();need(A.embed(capture,code,-1,header)==0,'embedded start') + for pc,(op,*args) in enumerate(code): + port=lambda t:header if t==0 else 3+t + nxt=pc+1 if pc+10,'reservation-entry boundary control') + self.names=list(g.rules);self.loc={n:i for i,n in enumerate(self.names)};self.loc['HALT']=-1 + self.rows=[[(self.loc[r.target],r.tests,r.writes,r.moves) for r in g.rules[n]] for n in self.names] + self.pc=self.loc[g.start];self.origins=[19*t-401 for t in range(35)];self.heads=self.origins.copy() + self.tapes=[{o:'^',o-7:'1',o+1000000:'0'} for o in self.origins] + for t,text in [(0,'^'+payloads[0]+'|'+payloads[1]+'|$')]+[(t,'^'+h+'|$101') for t,h in headers.items()]: + self.tapes[t].update({self.origins[t]+i:s for i,s in enumerate(text)}) + self.low=self.origins.copy();self.high=self.origins.copy();self.high[33]+=10*len(payloads[0]) + self.writes=[0]*35;self.steps=0 + def run(self,stop=None): + target=None if stop is None else self.loc[stop] + while self.pc!=-1 and self.pc!=target: + matches=[] + for rule in self.rows[self.pc]: + if all(self.tapes[t].get(self.heads[t],'_')==s for t,s in rule[1]):matches.append(rule) + if not matches:raise Rejected('no matching local-symbol rule') + need(len(matches)==1,'nondeterministic Graph') + nxt,_,writes,moves=matches[0] + for t,s in writes: + if s=='_':self.tapes[t].pop(self.heads[t],None) + else:self.tapes[t][self.heads[t]]=s + self.writes[t]+=1 + for t,d in moves: + need(d in (-1,0,1),'nonunit Graph movement');self.heads[t]+=d + self.low[t]=min(self.low[t],self.heads[t]);self.high[t]=max(self.high[t],self.heads[t]) + self.pc=nxt;self.steps+=1 + need(self.steps<100000000,'review execution cap') + def fields(self): + o=self.origins[0];t=self.tapes[0];pos=o+1;out=[] + for _ in range(2): + bits=[] + while t.get(pos) in ('0','1'):bits.append(t[pos]);pos+=1 + need(t.get(pos)=='|','HOME delimiter');pos+=1;out.append(''.join(bits)) + need(t.get(pos)=='$','HOME endpoint');return tuple(out) + + +def gamma(n): + b=bin(n)[2:];return '0'*(len(b)-1)+b +def header(shape):return ''.join(gamma(x) for x in shape) +def encode(values):return ''.join(format(x%64,'06b') for z in values for x in z) +def operator(values): + out=list(values) + for mask in (256,128): + for i in range(512): + if i&mask:continue + a,b=out[i];c,d=out[i|mask];rows=(a-b+c+d,a+b-c+d,a+b+c-d,-a+b+c+d) + need(all(x%2==0 for x in rows),'oracle exact halves') + out[i],out[i|mask]=(rows[0]//2,rows[1]//2),(rows[2]//2,rows[3]//2) + return out + + +def physical(): + rng=random.Random(8032026);values=[(4*rng.randrange(-1,2),4*rng.randrange(-1,2)) for _ in range(512)] + data=encode(values);parked=''.join(str(rng.randrange(2)) for _ in data);v=len(data) + hs={3:header((1,1,1,1,6,2)),34:header((1,1,1,1,6,1<<(v+5)))} + need(len(hs[34])>v,'genuinely E larger than DATA') + graph,stages=A.compile_home(2,header_tapes=(3,34,3));cpu=Sparse(graph,(parked,data),hs) + before=copy.deepcopy(cpu.tapes);old_high=cpu.high.copy();answers=[];snapshot=None + for event in range(3): + old_data=data;values=operator(values);data=encode(values);answers.append(data) + cpu.run(stages[event]['core_return']) + need(cpu.fields()==(parked,old_data),'HOME wrote before native return') + need(cpu.heads[3 if event!=1 else 34]==cpu.origins[3 if event!=1 else 34]+1,'borrowed origin+1') + need(all(cpu.heads[t]==cpu.origins[t]+2 for t in range(4,34)),'native origin+2') + if event==0:snapshot=copy.deepcopy(cpu) + cpu.run(stages[event]['primitive_return']) + need(cpu.fields()==(parked,old_data),'HOME wrote during private install') + need(all(cpu.tapes[t]==before[t] for t in range(4,34)),'native private retirement') + need(cpu.heads==cpu.origins,'all heads before scatter') + cpu.run(None if event==2 else stages[event+1]['adapter_entry']) + need(cpu.fields()==(parked,data),'exact rank2 DATA-only scatter') + need(all(a>=b for a,b in zip(cpu.high,old_high)),'historical backing reduced') + old_high=cpu.high.copy() + need(cpu.writes[0]==3*v and cpu.writes[3]==cpu.writes[34]==0,'public write counts') + need(cpu.heads==cpu.origins,'final heads') + need(all(cpu.tapes[t]==before[t] for t in range(1,35)),'final private/header/exterior equality') + rejected=[] + for kind in ('short','long'): + bad=copy.deepcopy(snapshot);end=bad.origins[4]+2+v + if kind=='short':bad.tapes[4].pop(end-1) + else:bad.tapes[4][end]='1' + try:bad.run() + except Rejected:pass + else:raise ValueError('returned extent mismatch accepted') + need(bad.writes[0]==0,'mismatch HOME write') + need(bad.tapes[0]==snapshot.tapes[0] and bad.tapes[3]==snapshot.tapes[3] and bad.tapes[34]==snapshot.tapes[34], + 'mismatch public bytes changed') + rejected.append(kind) + return {'rank':2,'V':v,'header_lengths':[len(hs[3]),len(hs[34])], + 'header_sequence':[3,34,3],'steps':cpu.steps,'HOME_writes':cpu.writes[0], + 'header_writes':[cpu.writes[3],cpu.writes[34]],'returned_extent_faults':rejected, + 'reachable_header_writes':cpu.reachable_header_writes, + 'unreachable_header_writes':cpu.unreachable_header_writes, + 'signed_origins':True,'final_output_sha256':sha256(data.encode()).hexdigest()} + + +if __name__=='__main__': + started=time.monotonic();count=relocation();packet=physical() + result={'marker':'PASS_INDEPENDENT_BORROWED_HEADER_DATA_REVIEW','embedded_instructions_checked':count, + 'packet':packet,'subject_freeze_sha256':sha256((SUBJECT/'FREEZE.json').read_bytes()).hexdigest(), + 'elapsed_seconds':round(time.monotonic()-started,3)} + (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n');print(json.dumps(result,sort_keys=True)) diff --git a/research/borrowed-header-data-only-home/review/packaging/BASE-FREEZE.json b/research/borrowed-header-data-only-home/review/packaging/BASE-FREEZE.json new file mode 100644 index 0000000000..6e94214313 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/packaging/BASE-FREEZE.json @@ -0,0 +1,406 @@ +{ + "schema": "borrowed-header-publication-freeze/1", + "status": "FROZEN_FOR_ROOT_PUBLICATION", + "utc": "2026-11-13 14:50 UTC", + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "author_freeze_sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7", + "generic_core_freeze_sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef", + "root_review_sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6", + "interface_original_manifest_sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f", + "registered_commands_passed": 5, + "metadata_and_source_pins": "PASS", + "files": [ + { + "path": "PACKAGING-CHECKS.json", + "bytes": 667, + "sha256": "687858f9cda0cf26081ae56164dc4036ff95337a8c7618c041d74336ced76ca8" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 3426, + "sha256": "db712d8d1e293f32bfa90adbae814c358a34558ab6cf9010b298e4b8452cac09" + }, + { + "path": "PR-TITLE.txt", + "bytes": 97, + "sha256": "6262878905310be0e87ed2eb44bfbd0ab5f902ef502deeaad50a99025b15e172" + }, + { + "path": "README.md", + "bytes": 8073, + "sha256": "4997af62940ba66bd8061af54f55e80d012b4ea4eaeeabb79b5eb707e39595ee" + }, + { + "path": "REGISTERED-metadata.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "REGISTERED-metadata.stdout", + "bytes": 69, + "sha256": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647" + }, + { + "path": "REGISTERED-registered.stderr", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "REGISTERED-registered.stdout", + "bytes": 4366, + "sha256": "91aa0cb9a85388792d2a66f20419c346bc705346a69235dba9611db714f2b42f" + }, + { + "path": "REVIEW-STATUS.json", + "bytes": 1122, + "sha256": "11aa4289474af475d0b13fa2351d7a279ab138508cbe5cfef1b168b38105a9bc" + }, + { + "path": "SOURCES.json", + "bytes": 5703, + "sha256": "b3d12097e54d9b9fdb6f8479048cda60eb806e8bf56813f2c1ff9f1ade742a44" + }, + { + "path": "TASK.json", + "bytes": 7276, + "sha256": "33ec6c87bd099f0b0618b867e946e0741fbeacc3eaa6d95a640668238e46aa37" + }, + { + "path": "VALIDATION.json", + "bytes": 1365, + "sha256": "1f8c42e4dc3d5a22a92985bc33c285052a72e45e5f2acf00fa60a54bd7cc4057" + }, + { + "path": "VERIFY.json", + "bytes": 2882, + "sha256": "97956d6f762f64c906ece40d1072fc16c7aae6c65b73caf5fa7fc8e20ed89456" + }, + { + "path": "implementation/CHECKPOINT.json", + "bytes": 1928, + "sha256": "eff4f815b85ceba1a6d41ad69e16c1e4c5ddc431943cdbcc9be6ae3747c77500" + }, + { + "path": "implementation/CHECKSUMS", + "bytes": 4955, + "sha256": "1466b78b44ccd6f965bcd93cfff57bdff9de19bef38cca6de1139a4be08534cf" + }, + { + "path": "implementation/FREEZE.json", + "bytes": 8658, + "sha256": "0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7" + }, + { + "path": "implementation/GRAPH.json", + "bytes": 881, + "sha256": "2e931768683a62754ccfa3564219b78b1f3963f0e22da257b71969e88de8dc6b" + }, + { + "path": "implementation/NOTICE.md", + "bytes": 1174, + "sha256": "38bb79d7a6a9533054c7ed0d18d8f3c8f1981afb207085edf8839226467aa040" + }, + { + "path": "implementation/PR-DRAFT.md", + "bytes": 1520, + "sha256": "80fce357cee91e2c354a079ebf517dc0f34a60d11fec741282e87d1af7e4e482" + }, + { + "path": "implementation/PREFLIGHT.md", + "bytes": 2329, + "sha256": "7a42a1eaad44d2d3b7833d59b4ee1f5446fb364389090c9808f3c80051edd5ef" + }, + { + "path": "implementation/PROOF.md", + "bytes": 12966, + "sha256": "667e4ffe2e676bd66181d023be8089c58e5c513de9afffa393be1a59a31d0744" + }, + { + "path": "implementation/README.md", + "bytes": 1959, + "sha256": "5a03b928581323c9e03fd1120b476df197340a60dfb4af40f05a1df84ce5ebb3" + }, + { + "path": "implementation/RESULT.json", + "bytes": 4081, + "sha256": "143b0fe2110229c2539b449ec8a4b15121bbf4b4e04c8eb0b69cc0578ce468e3" + }, + { + "path": "implementation/SOURCES.json", + "bytes": 12887, + "sha256": "2ee97e933b3098454ee9c86d376bbd11f83d0f5000fda14f1a284c6c300844c5" + }, + { + "path": "implementation/adapter.py", + "bytes": 6086, + "sha256": "182c34769407d5c1b07da4b6b7ac125098ba2c96669d4f965d1f5c8b6ba17f14" + }, + { + "path": "implementation/inputs/core/CHECKPOINT.md", + "bytes": 1877, + "sha256": "ae52c89420cbc468543b35bb41a258a39359328e3686e2b845a6b65e21209baa" + }, + { + "path": "implementation/inputs/core/ENVIRONMENT.json", + "bytes": 468, + "sha256": "77869ff81b59231e03707b857a5b0336c3ea3561e3894dc7e8132a6a12549c7b" + }, + { + "path": "implementation/inputs/core/FREEZE.json", + "bytes": 6301, + "sha256": "5735c401ba981a7af4d3a146eb047d04fa0c87dbf7ed49bd82dc57df8d6cb2ef" + }, + { + "path": "implementation/inputs/core/NOTICE.md", + "bytes": 1756, + "sha256": "4b90ab2e285248e040eb497a518c91de76075bee805a44d7f864483a5fa0a940" + }, + { + "path": "implementation/inputs/core/OVERLAP.md", + "bytes": 2859, + "sha256": "d25f870593857f4355838107b9e474190098d06f57dc658403f07e6643d4271c" + }, + { + "path": "implementation/inputs/core/PR-DESCRIPTION.md", + "bytes": 2398, + "sha256": "794daab8467df555f4891249d664487210137434d408ce11566efc3a2dab5885" + }, + { + "path": "implementation/inputs/core/PROOF.md", + "bytes": 12196, + "sha256": "48899c607452daccd0998f4005ae2a6ed85a723969f474bf796496303ad4d4bb" + }, + { + "path": "implementation/inputs/core/README.md", + "bytes": 3479, + "sha256": "7317240902788d46180bf9fea949197b66853c462a5f81d6598b603d085a748c" + }, + { + "path": "implementation/inputs/core/RESULT.json", + "bytes": 28741, + "sha256": "95c830d899981e4bb56174d1eebeff72e55629170c55b1f045f990218b4f86a3" + }, + { + "path": "implementation/inputs/core/SOURCE-BINDING.json", + "bytes": 1772, + "sha256": "ce90103e2981238badcb8adba444808c785af91ca4092b3390abdc989de03232" + }, + { + "path": "implementation/inputs/core/SOURCES.json", + "bytes": 5445, + "sha256": "496948cd8d2b5134ceed6b48b870be73f6415b5f70e97ab35b744ded5a2a3c03" + }, + { + "path": "implementation/inputs/core/adapter.py", + "bytes": 4845, + "sha256": "e7247705c4440b09b71a4a460fc169fc29e1bfbe36de2320ee3a09c9582c8534" + }, + { + "path": "implementation/inputs/core/bind_sources.py", + "bytes": 2850, + "sha256": "c4613ea17767bf8e82251d36cea9023b1436dc6e602c9378e456652598e816b6" + }, + { + "path": "implementation/inputs/core/join.py", + "bytes": 6778, + "sha256": "971080f6254cfaf44b01a412533818ffdff78ea925452c76a02524092b3ccff6" + }, + { + "path": "implementation/inputs/core/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/inputs/core/reference/pr6978-PROOF.md", + "bytes": 20312, + "sha256": "2943afc32745929374e8e55daff82b5fa78baa8a557d82b231d04b936c63c10d" + }, + { + "path": "implementation/inputs/core/reference/rank2/FREEZE.json", + "bytes": 5633, + "sha256": "072dfea997d4db796d492eaf746e0bd99630964741b88862d0f10f5fc1e00275" + }, + { + "path": "implementation/inputs/core/reference/rank2/PROOF.md", + "bytes": 16634, + "sha256": "93e1ad8a92c3624df064e4f39119ccbb5c96391ea8dd5f7af58edc7ca9638352" + }, + { + "path": "implementation/inputs/core/reference/rank2/RECIPE.json", + "bytes": 4468, + "sha256": "b1386ad613213a01f736bc2e7fc7de5a25d2c700c3d577dfb396a266278ae702" + }, + { + "path": "implementation/inputs/core/reference/rank2/SOURCES.json", + "bytes": 10337, + "sha256": "659ff7da20d16ece71aabbe240986e884fcaa6f53b5b0f082151e541e0534641" + }, + { + "path": "implementation/inputs/core/reference/rank2/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/inputs/core/reference/rank2/rank2.py", + "bytes": 8253, + "sha256": "3ca027f80b6cb973fa064612b8fb18b1306498e064a01e97ff7f9b6aa40b301a" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/parent_adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/home/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "implementation/inputs/core/reference/rank2/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "implementation/inputs/core/verify.py", + "bytes": 9469, + "sha256": "b83d5cc25712b08c67061de8262d2abe7c5872387ceb62b202b8207c9b117471" + }, + { + "path": "implementation/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "implementation/verify.py", + "bytes": 7746, + "sha256": "54b6b00812d865eb171cd970a4fa57c9c5938511b7500c0aac18bc9d9525a8b4" + }, + { + "path": "review/interface/PORTABILITY.json", + "bytes": 745, + "sha256": "90f6b2fd89c1ae65e8e5d82b77f8901025bce9599bde6b8d93e99fa3a024f911" + }, + { + "path": "review/interface/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/check_review.py", + "bytes": 9363, + "sha256": "d4ae614c5c3bf4dd166d224e5bbf48b196dddb7428749b2c1c745f20fd749fdb" + }, + { + "path": "review/interface/original/CHECKPOINT.md", + "bytes": 1125, + "sha256": "76a30d374d6f9bb5b6f1e55398407469aac2ce24897e1b22f57facb97b3dd495" + }, + { + "path": "review/interface/original/MANIFEST.json", + "bytes": 826, + "sha256": "ec51aefa22cd29e514084eefc2a203e2e91a724aeb058414344801e19bb7735f" + }, + { + "path": "review/interface/original/RESULT.json", + "bytes": 746, + "sha256": "5584c46e24df1d9b8e88a74eca7b2fb858ca10c18f8c66955397474cdabcdaf5" + }, + { + "path": "review/interface/original/REVIEW.md", + "bytes": 6093, + "sha256": "64821d0dd4b98d64b19ec0430af57caa1350452e6fc2007db2d193dcabab0a26" + }, + { + "path": "review/interface/original/check_review.py", + "bytes": 9157, + "sha256": "84344424ec0c1b775f43dd1aa04203c9d09dcf7684898947c614d4689fa01590" + }, + { + "path": "review/root/RESULT.json", + "bytes": 1360, + "sha256": "3dce8c4726b4a48b35098602cac893f8471d19ea1fb78617605495fa4aa96502" + }, + { + "path": "review/root/ROOT-REVIEW.md", + "bytes": 4608, + "sha256": "88bb48d8465741ce12fed45bd0e8d0e5bc3aae56be7e106a2e33accb938395f6" + }, + { + "path": "review/root/check_borrowed_root.py", + "bytes": 7464, + "sha256": "98e8991f6e85692dc523dab5479e2094072377f3cfbefe443959f3ce68013a2e" + } + ], + "excluded_paths": [ + "FREEZE.json(self)", + "PUBLICATION-MANIFEST.json", + "CHECKSUMS.sha256" + ], + "original_author_unchanged": true, + "root_and_original_interface_review_bytes_unchanged": true, + "portable_interface_adaptation": "Only CLI subject and read-only receipt comparison; elapsed_seconds alone excluded. See review/interface/PORTABILITY.json.", + "known_defects": [], + "scope": "Supplied immutable Gamma6 HEADER plus already-packed DATA-only HOME; no root producer/view/cutoff-policy/caller/nonleaf or kappa claim.", + "validation_global_mutated": false, + "remote_publication_performed": false +} diff --git a/research/borrowed-header-data-only-home/review/packaging/INTEGRATION-NOTE.md b/research/borrowed-header-data-only-home/review/packaging/INTEGRATION-NOTE.md new file mode 100644 index 0000000000..c645906250 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/packaging/INTEGRATION-NOTE.md @@ -0,0 +1,3 @@ +# Root publication integration + +After all five registered commands and both independent reviews passed, root added the exact base, reproduction command/expected marker and explicit predecessor links to the outer PR description. The original scientific implementation, proofs, source pins, review code, reviews, receipts and registered commands are unchanged. The original outer freeze is preserved as BASE-FREEZE.json. diff --git a/research/borrowed-header-data-only-home/review/root/RESULT.json b/research/borrowed-header-data-only-home/review/root/RESULT.json new file mode 100644 index 0000000000..e9fb2c6bbb --- /dev/null +++ b/research/borrowed-header-data-only-home/review/root/RESULT.json @@ -0,0 +1,48 @@ +{ + "E": 270, + "HOME_body_length": 14336, + "V": 14336, + "core_instructions": 25242, + "core_sha256": "c4d8abeb423b1f094d813916331d1fd89a905536a24b9719d450296f1f1fcabb", + "cutoff_bit_length": 130, + "input_sha256": "b3641704bfdf68f58aa5de106bb37bee9ce221db1e1967c625a15b7c6169e505", + "oracle": "Closed two-axis Hamming-distance Gaussian kernel; no author CPU/fixture/oracle imported", + "output_sha256": "e6dbee1eb349a832d3ef2821d4c66997eb65e61f5075d75d697b9143d7659de0", + "reachable_states": 25383, + "receipt": { + "HEADER_writes": 0, + "HOME_writes": 14336, + "checkpoints": { + "POSITIVE.69": { + "HOME_writes": 0, + "steps": 114767 + }, + "jump.5": { + "HOME_writes": 0, + "steps": 13626984 + }, + "jump.68": { + "HOME_writes": 0, + "steps": 13583910 + } + }, + "early_HOME_writes": 0, + "entry_head_history": 98987, + "final_head_history": 278941, + "header_read_first": 1, + "header_read_last": 270, + "steps": 13698674 + }, + "scope": "One fresh complete rank2 f1 DATA-only call with spectators and an immediate opaque HEADER suffix; no actual header/view producer or caller admission.", + "shape": [ + 1, + 1, + 1, + 2, + 7, + 680564733841876926926749214863536422913 + ], + "states": 25393, + "status": "PASS_ROOT_BORROWED_HEADER_RANK2", + "tapes": 34 +} diff --git a/research/borrowed-header-data-only-home/review/root/ROOT-REVIEW.md b/research/borrowed-header-data-only-home/review/root/ROOT-REVIEW.md new file mode 100644 index 0000000000..5b3b385538 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/root/ROOT-REVIEW.md @@ -0,0 +1,79 @@ +# Root review of the borrowed-header DATA-only adapter + +Base: e54523517d0f03e58352e647c403a5af3e525a57. +Author freeze:0f3f4bae39a8f630c56799912c41f2babecf0493531e043d6a6e0cb21ef717a7. + +## Decision and reviewed boundary + +The adapter's supplied-entry composition proof and a fresh rank-two physical +execution pass this review. The fixed-rank positive core remains unchanged. +One borrowed immutable Gamma6 header is distinct from DATA-only HOME, whose +extent is V rather than E+V. This fixes the representation-level dependence on +header length. It supplies no root-to-native header producer, actual address +view, packing, cutoff derivation or selected caller admission. + +Single-header service uses34 tapes. HEADER enters at B-relative1; native +DATA and private ports enter at2, leaving a blank guard at1 and permanent^0. +Mapping native port0 to HEADER3 and t>=1 to3+t is injective. The borrowed +header is not a native private bank and is never erased. The old B1 reservation +prefix uses tape3 as scratch but is unreachable from the declared already- +reserved execution entry. This entry restriction is necessary; the checker +independently traverses every reachable rule and rejects a HEADER write. +No claim is made that the original reservation prelude can borrow this header. + +The wrapper clones the V-bit operand into native DATA, restores the required +origins, runs the unchanged core, then installs exactly one returned DATA bit +per existing operand bit. Its sole successful end branch requires native +blank and operand delimiter simultaneously. Thus no incomplete returned +extent can reach successful B1 scatter. The original operand delimiter serves +as the length guide; no E-sized header is embedded into HOME. After local +cleanup, B1 returns the complete body to the same supplied owner. + +The prelude/postlude are bounded by6V+160, hence256(V+1); decoded-parameter, +cutoff and arithmetic work remain inside the unchanged2^24(fV+E+1) core bill. +Primitive history is bounded by entry+2112(V+E+1), retaining prior maxima. +B1 bank gathering/return, typed reservation, setup/origins and complete opaque +storage remain separate. E is not silently assumed O(V). At fixed f the +primitive is O(E+V), and no accelerated nonleaf tariff follows. + +## Separate physical and arithmetic check + +The root sparse CPU and closed two-axis Gaussian Hamming kernel are separate +from the author's interpreter, input fixture and oracle. It checks every core +instruction's injection and all Graph states reachable from the actual entry. +The fresh packet has rho2, f=r=P=1, S=2, width7 and a130-bit positive cutoff. +V=14,336, E=270, and each component is divisible by4 with magnitude at most8. +Two C axes therefore remain integral and bounded by32, inside signed7bits. +An immediate opaque suffix starts at the cell after the sixth Gamma code. + +The full34-tape execution takes13,698,674 transitions. It writes exactly +14,336 HOME bits after primitive return, zero HOME bits earlier, and zero +borrowed HEADER bits. Header read positions are exactly1..270, so the immediate +opaque suffix is not read. All34 heads/private bodies/guards/exteriors return, +the full borrowed header/suffix remain identical, and the parked HOME is +unchanged. The independently derived rank-two answer differs from the input +and from omitting the second C axis. This last check discriminates the fixture; +the author's separate suite provides actual emitted faulty-return mutants. + +Recorded head-span history grows from98,987 to278,941, retaining a prior +larger private extent. The checker separately includes a conservative B1 term +in its full time/history comparison. These recorded spans do not claim to +measure every supplied opaque exterior's past allocation. RESULT.json pins +the shapes, exact output and unchanged core instruction hash. + +Run with the explicit implementation directory: + +```sh +python3 -I -B -W error review/root/check_borrowed_root.py implementation +``` + +The author's two-header physical reuse (E10 and268 on the same V6144 body) +provides complementary evidence. Both headers are supplied initially; this +is not host-simulated production. Failure cleanup, interruption/retry and a +universal malformed-input validator remain unclaimed. Finite executions +corroborate the written all-size wrapper proof, not a full large-f replay. + +Prepared for @CubeJerry with substantial OpenAI ChatGPT/Codex assistance. +This is disclosed separate implementation/arithmetic checking, not blind or +human review or formal-kernel verification. All five selected assumptions, +the actual source producer/view/cutoff obligations and kappa remain unchanged. diff --git a/research/borrowed-header-data-only-home/review/root/check_borrowed_root.py b/research/borrowed-header-data-only-home/review/root/check_borrowed_root.py new file mode 100644 index 0000000000..018a63a2c9 --- /dev/null +++ b/research/borrowed-header-data-only-home/review/root/check_borrowed_root.py @@ -0,0 +1,116 @@ +"""Independent sparse machine and closed rank-two kernel for DATA-only borrowed HEADER.""" +from pathlib import Path +import hashlib,json,sys +P=Path(sys.argv[1]).resolve() if len(sys.argv)>1 else Path(__file__).with_name('source').resolve() +sys.path.insert(0,str(P)) +import adapter as a +def require(ok,why): + if not ok:raise ValueError(why) +def gamma(n): + b=bin(n)[2:];return '0'*(len(b)-1)+b +def word(n,w): + require(-(1<<(w-1))<=n<(1<<(w-1)),'signed fit') + return format(n%(1<>suffix_bits)).bit_count() + coefficient=mul(power((1,1),rank-h),power((1,-1),h)) + x=mul(coefficient,values[source*spectators+spectator]);z[0]+=x[0];z[1]+=x[1] + den=1<>3))%5-2),4*((3*address+s+(address>>5))%5-2)) for address in range(512) for s in range(spectators)] + expected=dense_image(values,spectators,2) + require(expected!=values and expected!=dense_image(values,spectators,1),'nontrivial exact rank2 fixture') + body=''.join(word(c,width) for z in values for c in z) + expected_body=''.join(word(c,width) for z in expected for c in z) + header=''.join(gamma(n) for n in (1,1,1,spectators,width,cutoff)) + parked=('001010011'*((len(body)+8)//9))[:len(body)] + actual,receipt=interpret(graph,(parked,body),header,stages) + require(actual==[parked,expected_body],'DATA-only output with independent tensor kernel') + require(receipt['HOME_writes']==len(body) and receipt['early_HOME_writes']==0,'exact DATA extent after primitive return') + V,E=len(body),len(header) + # One service, two HOMEs and at most two B1 operand buffers. B1 is paid + # separately from the primitive wrapper and inherited native core. + bound=(1<<24)*(V+E+1)+256*(V+1)+16*(1+1)*(2+2+1)*(V+2) + require(receipt['steps']<=bound,'complete core/wrapper/B1 time bill') + require(receipt['final_head_history']<=receipt['entry_head_history']+2112*(V+E+1)+8*(V+2),'primitive plus conservative B1 history') + print(json.dumps({'status':'PASS_ROOT_BORROWED_HEADER_RANK2','shape':[1,1,1,spectators,width,cutoff],'cutoff_bit_length':cutoff.bit_length(),'V':V,'E':E,'HOME_body_length':V,'states':len(graph.rules),'reachable_states':reachable,'tapes':a.TAPES,'core_instructions':len(core),'core_sha256':hashlib.sha256(repr(core).encode()).hexdigest(),'receipt':receipt,'input_sha256':hashlib.sha256(body.encode()).hexdigest(),'output_sha256':hashlib.sha256(expected_body.encode()).hexdigest(),'oracle':'Closed two-axis Hamming-distance Gaussian kernel; no author CPU/fixture/oracle imported','scope':'One fresh complete rank2 f1 DATA-only call with spectators and an immediate opaque HEADER suffix; no actual header/view producer or caller admission.'},indent=2,sort_keys=True)) +if __name__=='__main__':main()