diff --git a/research/source-bound-move-home-primitive/CHECKSUMS.sha256 b/research/source-bound-move-home-primitive/CHECKSUMS.sha256 new file mode 100644 index 0000000000..61027d8782 --- /dev/null +++ b/research/source-bound-move-home-primitive/CHECKSUMS.sha256 @@ -0,0 +1,46 @@ +22a53a789d76843647e6b07e3d3cb45b660c742d9ea10895264329e502e5eb8e FREEZE.json +e6f1509f15647534409019b43074792193594b5953ed6c4ae4144a48bd27afdd NORMAL.log +b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842 NOTICE.md +61cc6a0e823089f258b0fe58b5d9584475fe9618175f82e7e504ce840926aa87 OPTIMIZED.log +bcde513dfaaa4170da5a680c1950827f2bc84f151e059be9f220163fe6f17d16 OVERLAP.json +ca27a6e8ba9723e81edaad8ac27e98dfac51fca81becda2d30a22657ddba6506 PR.md +07386a1c142a6b233d8331ff6f58e3f1c2180fab01a948a24bd88df460e2dd4b PREFLIGHT.md +4beaa35f0d6637daa2bafac3fa0a1b7a66a18745dc936e94e3fcb3236f8798c2 PROOF.md +e9268ca3160b4aa75b37c8c4124beba1edb7b8a8a259aa51220f0294fdfeb093 README.md +be101121237cb6ea80fc10c1676e93b0ecf0c06529b3ae126cadde93bcd4c701 RESULT.json +8d057646621dab37c39d920b61140843357c43acd53319af37a488299db06068 REVIEW-FREEZE.json +073e33d01652487c11a7853bff9e4014dc58ad5a7efa7f22117f636f13b9a1cb SOURCES.json +04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099 adapter.py +9d39f6596a51aa8717908431017a51e69c3091145b03157087978b8c84073a94 inputs/dispatch/NOTICE.md +63f29469fd49751f267db6e26e3494e2bea567fa909d5ebfa2ec9a5924674a4e inputs/dispatch/PROOF.md +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 inputs/dispatch/tape_graph.py +7271c647d2d1e7f0f3ef80a6923ff194247eec1a4d8fd7dee4be626310e2026a inputs/native/NOTICE.md +aa7897029c9761fdf96c3336ab37c2827f08b0df29c868e3b2257ecc661ac7b6 inputs/native/PROOF.md +26d0ef51dda5fa599381f7f31dec4ba3a37f14f63ff9055ad1661dec2d02610c inputs/native/SOURCES.json +42e4293ab59ffa1c99e0dbbd5fded0833a5d726e1e794f0f263ae9a4686587a5 inputs/native/move.py +96fadb44c3316be93c6c02f50cd2c841a9541d67b98fd94fc47b73fa64dd404c inputs/native/reference/RECIPE.json +58f784587d1f21d6aaa1f6a14932779ff1f24d232496b042240e832939c9010d inputs/native/reference/SOURCE-FRAMES.json +773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf inputs/native/reference/leaf/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/native/reference/leaf/inputs/controller_reference.py +bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744 inputs/native/reference/leaf/leaf.py +2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50 inputs/native/reference/linear/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/native/reference/linear/inputs/controller_reference.py +d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33 inputs/native/reference/linear/linear.py +5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0 inputs/native/reference/phase/NOTICE +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/native/reference/phase/inputs/controller_reference.py +2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7 inputs/native/reference/phase/phase.py +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 inputs/native/reference/source/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 inputs/native/reference/source/native_verify.py +24f5e9957fcd8f6cfdc021ff5bc91bf89e50587997e2a2cb18053949c0e0d205 inputs/native/reference/translation/NOTICE.md +e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73 inputs/native/reference/translation/reference/inputs/controller_reference.py +4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245 inputs/native/reference/translation/reference/reverse.py +e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd inputs/native/reference/translation/translate.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee machine.py +c31ca791d15cbb44873073ac4e529924bfb9dabd35ff72b1025c866cb2993fdd oracle.py +8bf0a53061bb5e38e7465fd3cb14c02e8bce92f092fce4caa7da33278b79810c review/C-REVIEW.md +cb583affd51901b44ad5645bc0276a67d6319ffef76cfbf54dfc5a341654f74e review/PUBLICATION-REPLAY.txt +55b7ee7dd6f80ac00cc8137cdb7cac5e788d094a01076c16de14d07c1df4ab4f review/RESULT.json +a2591016d95fe6e95e1fee28f243e648c2003c029918b4b3144c4642473cab8e review/ROOT-REVIEW.md +79013c43107f5d212ac41cde6e324c69ba41175530fb3d0befaf7cd8e1506300 review/SOURCE-BINDING.json +3ef06776b67153c5618e8ace6240c7c76efb3e7bca24b26f8b3146234a19d688 review/check_adapter_root.py +2f04f1301f369c666acd8c88ce952c572c946672784ccbffbd147581b7e3bb49 verify.py diff --git a/research/source-bound-move-home-primitive/FREEZE.json b/research/source-bound-move-home-primitive/FREEZE.json new file mode 100644 index 0000000000..4cd635b1aa --- /dev/null +++ b/research/source-bound-move-home-primitive/FREEZE.json @@ -0,0 +1,60 @@ +{ + "status": "frozen_for_parent_review", + "time_utc": "2026-11-13T09:13:54.246400+00:00", + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "pins": { + "native": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "B1": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437" + }, + "python": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]", + "commands": [ + { + "argv": [ + "python", + "-I", + "-W", + "error", + "-B", + "research/source-bound-move-home-primitive/verify.py" + ], + "exit_code": 0, + "log": "NORMAL.log" + }, + { + "argv": [ + "python", + "-I", + "-O", + "-W", + "error", + "-B", + "research/source-bound-move-home-primitive/verify.py" + ], + "exit_code": 0, + "log": "OPTIMIZED.log" + } + ], + "summary": { + "marker": "PASS_SOURCE_BOUND_MOVE_HOME_PRIMITIVE", + "graph_states": 82980, + "tapes": 35, + "F": 4106, + "E": 10, + "V": 4096, + "successful_steps": 14495822, + "rejection_steps": 4748143, + "HOME_writes_success": 4106, + "HOME_writes_rejection": 0, + "controls": [ + "dropped_header_return", + "wrong_home_return", + "monitor_detects_native_guard_write_over_B_origin", + "arithmetic_rejection_before_HOME_mutation", + "raw_zero_is_not_formatted_packet", + "frozen_native_core_source_corruption" + ], + "core_graph_sha256": "14f38b15157a9c9cd2828861f6904701a29b1e27507a7e43d60030e1ae4d9238" + }, + "scope": "One typed actual MOVE24472 HOME primitive; formatted-entry and source numerical/cutoff promises retained; no initializer/caller admission or kappa change.", + "external_review": "Parent root-work/adapter-review, retained separately by parent." +} diff --git a/research/source-bound-move-home-primitive/NORMAL.log b/research/source-bound-move-home-primitive/NORMAL.log new file mode 100644 index 0000000000..93acbfe820 --- /dev/null +++ b/research/source-bound-move-home-primitive/NORMAL.log @@ -0,0 +1,374 @@ +{ + "E": 10, + "F": 4106, + "HOME_writes_rejection": 0, + "HOME_writes_success": 4106, + "V": 4096, + "controls": [ + "dropped_header_return", + "wrong_home_return", + "monitor_detects_native_guard_write_over_B_origin", + "arithmetic_rejection_before_HOME_mutation", + "raw_zero_is_not_formatted_packet", + "frozen_native_core_source_corruption" + ], + "core_completed_prefix_steps": 14462894, + "core_graph_sha256": "14f38b15157a9c9cd2828861f6904701a29b1e27507a7e43d60030e1ae4d9238", + "core_locations": 82813, + "fixture": "all odd real signs and zero imaginary; half-integral source-column contributions cancel before the final integrality test", + "graph_states": 82980, + "history_boundary": "K_entry also includes preserved opaque exterior storage and any earlier history; reported head windows do not infer the full entry backing", + "input_sha256": "0705d5d1fc729a47e0da3400d35f660b88b41b643a9a5a1bbb64e9dec4ef15d9", + "marker": "PASS_SOURCE_BOUND_MOVE_HOME_PRIMITIVE", + "monitored_entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 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, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 12341 + ] + ], + "monitored_final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 19 + ], + [ + 20, + 32 + ], + [ + 21, + 4119 + ], + [ + 22, + 4120 + ], + [ + 23, + 4121 + ], + [ + 17, + 4115 + ], + [ + 18, + 4116 + ], + [ + 19, + 33 + ], + [ + 20, + 4118 + ], + [ + 21, + 25 + ], + [ + 22, + 4120 + ], + [ + 23, + 2073 + ], + [ + 17, + 2067 + ], + [ + 18, + 32 + ], + [ + 19, + 4117 + ], + [ + 20, + 2070 + ], + [ + 21, + 4119 + ], + [ + 22, + 33 + ], + [ + 23, + 153 + ], + [ + 17, + 2067 + ], + [ + 18, + 1044 + ], + [ + 19, + 2069 + ], + [ + 20, + 2070 + ], + [ + 21, + 2071 + ], + [ + 22, + 2072 + ], + [ + 23, + 2073 + ], + [ + 17, + 1043 + ], + [ + 18, + 1044 + ], + [ + 19, + 1045 + ], + [ + 20, + 4118 + ], + [ + 21, + 29 + ], + [ + 22, + 4120 + ], + [ + 23, + 12341 + ] + ], + "output_sha256": "a4134e195c5e558bd0e48438d662ba6aee71c4f7a56a71bfbb3e064afe56ac22", + "parked_sha256": "ce30cf974a0b7471dcd93af93930713d1e4096ad19057213c0c60b97341b3abb", + "parser_cases": [ + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 32, + "F": 40, + "cutoff_bitlength": 8, + "retained_guide_extent": 121, + "steps": 827 + }, + { + "E": 144, + "F": 152, + "cutoff_bitlength": 64, + "retained_guide_extent": 457, + "steps": 2675 + }, + { + "E": 532, + "F": 540, + "cutoff_bitlength": 258, + "retained_guide_extent": 1621, + "steps": 9077 + }, + { + "E": 2066, + "F": 2074, + "cutoff_bitlength": 1025, + "retained_guide_extent": 6223, + "steps": 34388 + }, + { + "E": 8210, + "F": 8218, + "cutoff_bitlength": 4097, + "retained_guide_extent": 24655, + "steps": 135764 + } + ], + "ready_before_scatter_steps": 14475282, + "rejection_steps": 4748143, + "scope": "actual exact selected MOVE24472 primitive; supplied packed entry, cutoff and numerical admission; no initializer or complete caller", + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "successful_steps": 14495822, + "tapes": 35 +} +elapsed_seconds 7.464 diff --git a/research/source-bound-move-home-primitive/NOTICE.md b/research/source-bound-move-home-primitive/NOTICE.md new file mode 100644 index 0000000000..db83fd95e1 --- /dev/null +++ b/research/source-bound-move-home-primitive/NOTICE.md @@ -0,0 +1,35 @@ +# Notice and attribution + +New adapter, proof, direct-frame packing oracle and verification integration: +Apache-2.0, prepared with substantial OpenAI Codex assistance. No independent +human or proof-kernel acceptance is asserted. + +The unchanged MOVE join is the integer-multiplication project's exact +selected-MOVE core at 3a27ab1d302d13b1ce52411f8a174e7a32baab77. Its whole-call +transaction, numerical/cutoff theorem and literal factor composition remain +credited to that contribution. The unchanged native factors are Jerry Chen / +CubeJerry #7426 phase, #7430 binary maps, #7428 translation, #7429 positive C +leaf and transitively #7427 reversal. Their original notices are retained. +They retain Ali Romman, Jose Manuel Barranco, alejandrozu, DreamingOfClouds, +Cinna Davis, zxv, unpaidmoon, icekylinx and the broader native/P104, exact +Gaussian, tensor, phase, physical mapping and controller lineage. + +B1 at b4fcc9d64971fdabd0b1d82cfb749d8aac920437 supplies the permanent-home +graph constructor and source-codec/finite-dispatch theorem. Its NOTICE and +proof remain unchanged, including Jacob Alan Sussman/#4268, zxv/#4359, +Mihir Srivastava/#4507/#5071, Matarener/#4691 and the #6878 layout lineage. + +The expected-value engine is the retained independent Gaussian original-frame +interpreter, not the source's scalar/CNOT/phase graph. This package adds the +natural-coordinate-to-packed addressing and complete numerator accumulation; +it does not claim that engine as newly authored independent mathematics. + +Classical Gamma coding, unary length guides, instruction relocation, exact +copy/repack and staged commit are credited prior methods. The added object is +the explicit six-code||DATA single-field ABI, paid native guard shift and +full selected-MOVE-to-same-HOME composition. + +CubeJerry #6996 and Nick Petalas #7211 use different rounded #6030 Count/Tape +formats. #7462's shorter left word, #7468's endpoint scale and #7477's reversal +failure cleanup remain related work; none is installed here. Source proposals +and this scoped primitive do not certify a selected multiplier or change κ. diff --git a/research/source-bound-move-home-primitive/OPTIMIZED.log b/research/source-bound-move-home-primitive/OPTIMIZED.log new file mode 100644 index 0000000000..cfac217586 --- /dev/null +++ b/research/source-bound-move-home-primitive/OPTIMIZED.log @@ -0,0 +1,374 @@ +{ + "E": 10, + "F": 4106, + "HOME_writes_rejection": 0, + "HOME_writes_success": 4106, + "V": 4096, + "controls": [ + "dropped_header_return", + "wrong_home_return", + "monitor_detects_native_guard_write_over_B_origin", + "arithmetic_rejection_before_HOME_mutation", + "raw_zero_is_not_formatted_packet", + "frozen_native_core_source_corruption" + ], + "core_completed_prefix_steps": 14462894, + "core_graph_sha256": "14f38b15157a9c9cd2828861f6904701a29b1e27507a7e43d60030e1ae4d9238", + "core_locations": 82813, + "fixture": "all odd real signs and zero imaginary; half-integral source-column contributions cancel before the final integrality test", + "graph_states": 82980, + "history_boundary": "K_entry also includes preserved opaque exterior storage and any earlier history; reported head windows do not infer the full entry backing", + "input_sha256": "0705d5d1fc729a47e0da3400d35f660b88b41b643a9a5a1bbb64e9dec4ef15d9", + "marker": "PASS_SOURCE_BOUND_MOVE_HOME_PRIMITIVE", + "monitored_entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 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, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 12341 + ] + ], + "monitored_final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 19 + ], + [ + 20, + 32 + ], + [ + 21, + 4119 + ], + [ + 22, + 4120 + ], + [ + 23, + 4121 + ], + [ + 17, + 4115 + ], + [ + 18, + 4116 + ], + [ + 19, + 33 + ], + [ + 20, + 4118 + ], + [ + 21, + 25 + ], + [ + 22, + 4120 + ], + [ + 23, + 2073 + ], + [ + 17, + 2067 + ], + [ + 18, + 32 + ], + [ + 19, + 4117 + ], + [ + 20, + 2070 + ], + [ + 21, + 4119 + ], + [ + 22, + 33 + ], + [ + 23, + 153 + ], + [ + 17, + 2067 + ], + [ + 18, + 1044 + ], + [ + 19, + 2069 + ], + [ + 20, + 2070 + ], + [ + 21, + 2071 + ], + [ + 22, + 2072 + ], + [ + 23, + 2073 + ], + [ + 17, + 1043 + ], + [ + 18, + 1044 + ], + [ + 19, + 1045 + ], + [ + 20, + 4118 + ], + [ + 21, + 29 + ], + [ + 22, + 4120 + ], + [ + 23, + 12341 + ] + ], + "output_sha256": "a4134e195c5e558bd0e48438d662ba6aee71c4f7a56a71bfbb3e064afe56ac22", + "parked_sha256": "ce30cf974a0b7471dcd93af93930713d1e4096ad19057213c0c60b97341b3abb", + "parser_cases": [ + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 32, + "F": 40, + "cutoff_bitlength": 8, + "retained_guide_extent": 121, + "steps": 827 + }, + { + "E": 144, + "F": 152, + "cutoff_bitlength": 64, + "retained_guide_extent": 457, + "steps": 2675 + }, + { + "E": 532, + "F": 540, + "cutoff_bitlength": 258, + "retained_guide_extent": 1621, + "steps": 9077 + }, + { + "E": 2066, + "F": 2074, + "cutoff_bitlength": 1025, + "retained_guide_extent": 6223, + "steps": 34388 + }, + { + "E": 8210, + "F": 8218, + "cutoff_bitlength": 4097, + "retained_guide_extent": 24655, + "steps": 135764 + } + ], + "ready_before_scatter_steps": 14475282, + "rejection_steps": 4748143, + "scope": "actual exact selected MOVE24472 primitive; supplied packed entry, cutoff and numerical admission; no initializer or complete caller", + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "successful_steps": 14495822, + "tapes": 35 +} +elapsed_seconds 7.368 diff --git a/research/source-bound-move-home-primitive/OVERLAP.json b/research/source-bound-move-home-primitive/OVERLAP.json new file mode 100644 index 0000000000..bddc4df0df --- /dev/null +++ b/research/source-bound-move-home-primitive/OVERLAP.json @@ -0,0 +1,50 @@ +{ + "date": "2026-11-13", + "canonical": "e54523517d0f03e58352e647c403a5af3e525a57", + "queries": [ + { + "query": "repo:CrocSwap/integer-mult-bounds \"MOVE\" \"header\" \"packed\" is:pr", + "total_count": 0, + "incomplete_results": false, + "results": [] + }, + { + "query": "repo:CrocSwap/integer-mult-bounds \"MOVE24472\" is:pr", + "total_count": 3, + "incomplete_results": false, + "results": [ + { + "number": 7430, + "title": "Implement both selected Gaussian linear maps as fixed tape programs with every column and complete owner return" + }, + { + "number": 7426, + "title": "Lower the current selected quadratic Gaussian phase to a fixed tape table with complete owner return" + }, + { + "number": 7462, + "title": "Remove two CNOTs from the selected left binary map (no κ)" + } + ] + } + ], + "rounded_predecessors": [ + { + "number": 6996, + "title": "Research: Rounded selected MOVE", + "head": "e573186e695f85cb5dbb32ee13ba20ca3159d62a", + "scope": "Different rounded #6030 Count/Tape interface; no packed six-Gamma single-field adapter." + }, + { + "number": 7211, + "title": "Lower rounded-MOVE component width to h+2ceil(rf/2)+1 (no κ)", + "head": "2b882fd2834303655f82d084e25dc551f67e9784", + "scope": "Different rounded #6030 Count/Tape interface; no packed six-Gamma single-field adapter." + } + ], + "pins": { + "native": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "dispatcher": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437" + }, + "coverage": "Bounded public metadata audit and supplied exact-source review. No all-history/literature-wide novelty or hidden work claim. No public post by this worker." +} diff --git a/research/source-bound-move-home-primitive/PR.md b/research/source-bound-move-home-primitive/PR.md new file mode 100644 index 0000000000..3b9011bd9b --- /dev/null +++ b/research/source-bound-move-home-primitive/PR.md @@ -0,0 +1,63 @@ +# Bind the selected MOVE24472 to permanent HOME fields with a paid packet interface and restored tape owners + +This composes two scoped results that previously had different boundaries: +the selected literal MOVE core has distinct Gamma HEADER/DATA owners, while +the permanent-home dispatcher transports one complete binary field. The new +paid graph splits all six codes from the full packed DATA, executes the +unchanged 82,813-instruction source core, repacks to the same working field +and returns it to the identical HOME owner. + +The actual core is pinned at 3a27ab1d302d13b1ce52411f8a174e7a32baab77 and +B1 at b4fcc9d64971fdabd0b1d82cfb749d8aac920437. Native origins are shifted +from B cell 0 to cell 2, keeping native guards on blank cell 1 and permanent +`^` markers intact. All runtime work is literal symbol tests, writes, unit +moves and fixed control; no Python numerical/factor callback remains. + +The typed primitive has bill `128(F+1)+2^24(fV+E+1)` and retained history +`K_entry+1088(F+1)`, where F includes every cutoff/header bit and complete +scientific DATA. B1's separate O(RKF) delivery remains charged. A fixed admitted +leaf cutoff gives O(F) complete-field service; no faster nonleaf rate is claimed. + +## Reproduction and evidence + +```sh +python3 -I -W error -B research/source-bound-move-home-primitive/verify.py +python3 -I -O -W error -B research/source-bound-move-home-primitive/verify.py +``` + +The complete f=1,m=9 packet includes 512 Gaussian entries with odd real signs +and zero imaginary parts. A separate original-frame Gaussian kernel sums all +numerators before dividing, allowing half-integral basis terms to cancel. +The 35-tape, 82,980-state HOME/core/HOME graph takes 14,495,822 transitions, +returns every head/guard/marker/body, and preserves another arbitrary same-F +HOME. All 4106 HOME writes occur after successful primitive return. The +nonintegral rejection prefix takes 4,748,143 transitions with zero HOME writes. + +Seven parser-only identity probes include cutoff bit length4097. Six controls +cover header loss, wrong HOME, an observer-detected forbidden origin-write +attempt from a wrong guard shift, public preservation on arithmetic rejection, +raw zero versus formatted entry, and an actually corrupted source copy. +Header/return fault checks start from genuine successful full-core snapshots; +they do not rerun a substituted numerical core. + +## Scope and attribution + +Supplied promises remain the six-positive-Gamma packed entry, common grid, +signed width, numerical admission and cutoff. Raw owned zeros are not an +initializer. Rejection retirement/retry, complete selected compiler/source +generation, endpoint scaling, faster recurrence and analytic recovery remain +open. All five assumptions and selected κ=.00363005817 are unchanged. + +The existing source core and B1 retain their theorem/construction credit. +CubeJerry #7426/#7428/#7429/#7430/#7427, the original selected/native/physical +lineage, and the independent Gaussian frame engine retain their notices. +#6996/#7211 use different rounded #6030 formats; no variant is substituted. +All new work is isolated to this package. Prepared for @CubeJerry with substantial OpenAI +Codex assistance; no independent human or kernel acceptance. + +Open next questions: one actual source producer with complete format/grid/ +cutoff/transport invoice, or a separate full failure-retirement transformer. + +## Independent checks + +A separate sparse signed-origin Graph interpreter and exact integer forward-address oracle execute a fresh complete odd-valued packet. All 82,813 transplanted instructions are checked individually. A second written review checks the parser, guard seam, full time/history bill and the absence of a reserve-guide collision in this two-HOME graph. All 24 immutable inputs match exact previously remote-verified predecessor trees. Review scripts, receipts and limitations are in `review/`. The selected frontier cold replay is not claimed. diff --git a/research/source-bound-move-home-primitive/PREFLIGHT.md b/research/source-bound-move-home-primitive/PREFLIGHT.md new file mode 100644 index 0000000000..c43d57cbdf --- /dev/null +++ b/research/source-bound-move-home-primitive/PREFLIGHT.md @@ -0,0 +1,57 @@ +# Bounded MOVE/home ABI preflight + +Canonical main: e54523517d0f03e58352e647c403a5af3e525a57, refreshed by the +parent before this wave. This is a separate package; the frozen B1 dispatcher +and the published native MOVE core remain read-only. + +Exact target: one actual selected MOVE24472, public field owner unchanged. +Input to B1 is `Gamma(f)||Gamma(r)||Gamma(P)||Gamma(S)||Gamma(w)||Gamma(cutoff)||DATA`, +all six positive, with F=E+V binary bits and the outside B delimiter `|`. +DATA is the complete packed `V=2 P S r 2^(9f) w` field. The numerical and +cutoff admission are exactly the published native core's supplied premises. +No initializer or actual selected caller is inferred from raw owned zeros. + +The core at 3a27ab1d302d13b1ce52411f8a174e7a32baab77 has 31 tapes and 82,813 +literal read/write/unit-move/goto/halt locations. It accepts distinct HEADER +and DATA owners. All core origins can be shifted to cell 2: its private guards +then occupy blank cell 1, while B's permanent `^` at cell 0 is untouched. +The source program's public-preserving transaction commits only after every +factor succeeds. On arithmetic rejection, B's HOME has not yet been scattered. +No rejected-bank cleanup/reuse is proposed. + +Proposed finite construction: split six Gamma codes by a unary *length* guide, +without decoding their values; copy the remaining binary DATA body separately; +translate the actual core table offline to B graph rules at fixed private ports; +on successful halt repack HEADER and DATA to the same B operand, erase the two +core public copies and return all 31 core heads from offset 2 to B origin 0. +Every parse/copy/repack/reset and shifted guard is a paid graph operation. +A separate private Gamma-length guide uses only O(E) time/space, including a +huge encoded cutoff. No runtime factor callback or integer decode drives the +machine. All f/precision-dependent work remains in the actual core graph. + +Optimistic complete successful bill: C(F+1)+2^24(fV+E+1), plus B1's existing +O(R K (F+1)) gather/return bill. Core-table translation has one B graph +transition per retained instruction (read branches remain scanned-symbol +branches); adapter phases add only O(F) local transitions. At a fixed admitted +leaf cutoff, this is linear in the complete F-bit field. Historical capacity +is entry history plus O(F+1) adapter visits plus the core's 1024(V+E+1) +increment; no erased prior capacity is subtracted. + +Success test: full nonzero f=1, m=9 packet through actual HOME gather, the +translated complete core, and same-HOME scatter; a second same-F source home +remains arbitrary and untouched. Expected values use a separate exact selected +kernel, and controls cover header loss, guard offset, wrong home and arithmetic +rejection before any HOME mutation. Small parser-only tests include large +encoded cutoff lengths; these do not substitute for the full packet run. + +Bounded overlap: GitHub API search `repo:CrocSwap/integer-mult-bounds MOVE header +packed is:pr` returned zero matches (incomplete_results=false); MOVE24472 +returned #7430, #7426 and #7462. Those implement the retained source factors +or a different shortened left word, not the B1 single-field ABI. Parent's broad +literal-rounded comparison identified #6996/#7211, whose Count/Tape formats +are distinct. This is a bounded public metadata check, not proof of novelty. + +Exclusions: other native operators, all-word generation, faster nonleaf rates, +endpoint scaling, actual caller/initializer admission, numerical-producer repair +and rejected-bank cleanup. Stop with a precise obstruction if shifted origins, +cleanup or complete-field accounting cannot be proved. diff --git a/research/source-bound-move-home-primitive/PROOF.md b/research/source-bound-move-home-primitive/PROOF.md new file mode 100644 index 0000000000..910ba607a4 --- /dev/null +++ b/research/source-bound-move-home-primitive/PROOF.md @@ -0,0 +1,234 @@ +# One actual selected MOVE as a permanent-home primitive + +Scoped constructive composition, prepared with substantial OpenAI Codex +assistance, Apache-2.0. Canonical main is +`e54523517d0f03e58352e647c403a5af3e525a57`. No new κ or assumption discharge. + +## 1. Sources, domain and exact claim + +Use the unchanged exact native core at +`3a27ab1d302d13b1ce52411f8a174e7a32baab77`, +`research/literal-selected-move-join/`. Its fixed 31-tape, 82,813-location +program is the actual selected #7000 event 24472, +`["MOVE",415,3,99,false]`, from source frames `[]` to `[239]`. +The complete numerical/tensor theorem and source extraction are credited +predecessor premises, not new native algebra results. The dispatcher is B1 at +`b4fcc9d64971fdabd0b1d82cfb749d8aac920437`, +`research/compiler-permanent-home-dispatch/tape_graph.py`. SOURCES.json pins +the small unchanged source closure, notices and frame witness. No Git object, +archive extraction, shared checkout or runtime callback is needed for replay. + +One selected HOME body is the following binary packet, immediately followed +by B1's outside `|`: + +``` +Gamma(f) Gamma(r) Gamma(P) Gamma(S) Gamma(w) Gamma(cutoff) DATA +``` + +Gamma is the positive canonical code `0^(bitlength(n)-1)||binary(n)`. +All six integers are positive, w>=2, and E counts **all six** code lengths. +DATA is exactly the complete source-core packed field with +`V=2 P S r 2^(9f) w` bits. Thus the whole body has `F=E+V` bits. It includes +every P/S spectator address, all r Gaussian coefficients and every one of the +9f native coordinate bits. No extra binary tail after DATA is admitted. +Signed components are w-bit MSB-first two's-complement on the supplied common +grid, exactly as in the core. The first native coordinate is the slow block. + +Retain the source core's entire accepting promise: f<=cutoff; all executed +phase negations/rotations fit the signed width; and every low-bit-first C +axis is integral on the common grid and fits the width. No internal rounding, +scale conversion or endpoint-only replacement of that promise is made. + +At primitive entry, its B operand is `^ packet |`, with head at `^` at relative +cell 0. Supply 32 distinct private tapes, disjoint from this operand, HOME, +all other operands and each other. Each has B's permanent `^` at cell 0 and +head there. The positive regions needed by this adapter and core, beginning +at cell 1, are blank; their opaque exteriors are disjoint. Earlier history, +including larger erased buffers and exterior storage, remains charged. +The common-F HOME layout and this formatted semantic packet are supplied ABI +inputs. Raw owned `0^F` is not a packet or a proved initializer. + +**Theorem.** On every such accepted packet, `primitive` emits one fixed +uniform graph which implements the exact complete MOVE on DATA, preserves +the six header codes, returns the complete packet to the same B operand, +returns every private head to B origin 0, restores every private body/guard +and permanent marker, and preserves opaque exteriors. Composing it with B1 +gather/return changes only the selected original HOME. Other homes remain +arbitrary complete spectator fields. This instantiates one typed primitive, +not the full selected caller or compiler. + +## 2. Tape injection and the guard seam + +The full two-operand B1 machine uses HOME=0, working operand=1 and unused +operand=2. Inject the core's local tape t as global tape t+3, for t=0,...,30. +They are HEADER=3, DATA=4 and native private ports 5,...,33. Guide=34 is a +separate adapter-private tape. There are 35 fixed tapes; private primitive +count is 32. No two core ports or outside public owners are identified. + +Move each core tape from B origin 0 to **native origin 2**. A native private +guard at native origin-1 therefore occupies blank cell 1. B's `^` at cell 0 +is at native origin-2, outside every source-private guard/body window. Native +public HEADER/DATA can also have blank cell 1. This meets the core's supplied +entry and opaque-exterior premises. Literal read/write/unit-move programs +are equivariant under independent translations of their tape origins, so the +same argument applies at arbitrary signed physical origins. All positions +here are relative to the permanent B marker. + +It would be invalid to place native origin at cell 1: its private guard would +overwrite B's `^`. The wrong-offset fault is detected by a **test monitor** +observing an attempted marker write. The compiled machine contains no such +runtime protection, and this monitor is not used to establish healthy control. + +## 3. Exact six-code split without value decoding + +Copy every header bit to private HEADER while scanning the B operand once. +For each of the six codes, the guide holds one unary 1 per prefix zero. +On the first 1, move the guide back one cell. Each guide 1 is erased and +permits exactly one suffix bit to be copied. Reaching guide `^` ends that +code; move one cell right to begin the next prefix. Code count six is unrolled +in fixed control. All guide digits are erased after the sixth code. + +For a code with z prefix zeros, exactly z suffix bits are consumed. This +inductively places the operand head at the first DATA bit after the six +codes, with HEADER containing precisely those E bits, followed by blank. +No integer value is decoded. In particular, cutoff can have an arbitrarily +large numerical value: parsing depends only on its encoded bit length. + +Copy every remaining DATA bit until the B outside `|` to private DATA, +without copying that delimiter. DATA now has exactly V bits followed by +blank. Return private HEADER and DATA to native origin 2 using B's `^` as +the known rewind boundary and the fixed +2 shift. Return guide and B operand +heads to B origins. The B operand is unchanged throughout this preparation. +The other 29 core tapes are blank at native origin 2. Hence the exact source +core boundary holds, including the sixth encoded cutoff, complete DATA, +distinct owners, guards, common grid and numerical admission. + +## 4. Literal core substitution and same-owner return + +`embed` copies the actual core table, not a substitute numeric kernel. A +source read becomes the same scanned-symbol branches on tape t+3; a write +or unit move performs that same action; a fixed goto renames its address; +and successful halt becomes one goto to the repacking continuation. Empty +reads remain actual rejecting states. One source instruction is one Graph +transition, including the terminal halt replacement. The table is assembled +offline and contains no Python factor call at runtime. + +By induction on source instructions, the embedded run is the original core +run with port injection and translated origins. The credited all-f theorem +therefore supplies the complete exact MOVE, original HEADER, all 31 native +heads at origin 2, retired native private bodies/guards and preserved opaque +exteriors. It does not merely supply a scalar or two-component child sample. + +Only after that complete return, copy HEADER then completed DATA to the B +operand beginning at cell 1. Erase those two private streams during copying. +Because HEADER still has E bits and DATA V bits, the operand head reaches +exactly its original outside `|`; the graph checks that marker. Return B, +HEADER and DATA heads to their B origins. All other core-private tapes are +already blank and at native origin 2: two left moves return them to B origin +0 without writing a marker. Guide is already erased at B origin 0. This +restores every private bank and permits successful same-format reuse. + +B1 then scatters the completed F-bit body to the same immutable HOME owner +and erases its working duplicate. The entire packet, including header, is +charged. A second same-F HOME is scanned but never written. No private copy +earns productive credit. This transports values and does not change owner +identity or project out native coordinates or spectators. + +## 5. Rejection boundary + +No adapter instruction before successful core completion writes the B +operand, and no adapter/core instruction writes HOME. HOME writes occur only +in B1's later scatter. A finite arithmetic/cutoff rejection therefore leaves +all original HOME contents unchanged. The concrete rejected packet reaches +an undefined native scanned-symbol branch after completed private factors; +it has zero HOME writes. Rejected private banks need not be erased or have +heads returned, and no retry/reuse is claimed. Accepted numerical/cutoff +admission guarantees successful primitive completion under the source theorem. +Malformed packets and arbitrary interruption have no new general cleanup or +running-time claim. The raw-zero control is one explicit rejected example. + +## 6. Full time, finite cutoff and retained history + +The adapter uses only local scans. For a Gamma code with z prefix zeros, +prefix/suffix copying and guide retirement use at most 3z+2 transitions. +Summing over six codes is at most 2E+6. DATA copying is V+1. Public-stream +and operand rewinds, shifted-origin handoffs, repacking, copy erasure and +all 31 head resets add at most 5F+148 more transitions. Thus a deliberately +larger **standalone primitive** upper bound is + +`T_mu <= 128(F+1) + 2^24(fV+E+1)`. (1) + +The second summand is the unchanged complete source-core bill. It already +includes runtime header decoding, descriptors, coefficients, every C axis, +phase/G/translation, all core copies/commits, guard resets and cleanup. Native +table generation, fixed port injection and graph serialization are finite +compile-time work. Varying f, precision/shape work and the encoded cutoff are +never treated as compiled constants or hidden callbacks. + +B1 still pays its existing `O(R K(F+1))` gather/return bill. For the concrete +one-event two-HOME graph, direct scan counting also fits the complete bound +in (1): the local constant 128 has ample room for those additional scans. +It is not a free delivery claim for a larger compiler. Logical productive +volume stays B*F under B1's format contract; the private HEADER/DATA/guide/core +banks create no extra productive width. + +If a caller separately supplies a fixed leaf cutoff q with f<=q and the +encoded comparison f<=cutoff holds, (1) is `O_q(F+1)`. q bounds f, not the +numerical cutoff value or its code length: all cutoff bits remain in E. +No faster nonleaf rate or ordinary recurrence is proved. + +Let K_entry include complete earlier history of every participating owner, +including opaque exterior storage. Splitting visits at most E+3 HEADER and +V+3 DATA cells relative to B, at most E+2 guide cells, and a fixed number of +alignment cells. Repacking/returns stay within those spans, the existing +operand extent or the core's visited intervals. A generous adapter increment +is `64(F+1)`. The credited core increment is `1024(V+E+1)`. Therefore + +`K_final <= K_entry + 1088(F+1)` (2) + +for the primitive. Add B1's separately charged operand/home history where +needed. All increments are unions/maxima at fixed owner origins, not a new +allocation per phase. Erasure removes contents, not historical capacity. +No entry+current-volume bound is inferred after a larger earlier call. +The verifier retains an explicitly larger old guide window. Its reported +head-span windows are instrumentation, not an inferred complete K_entry; +opaque exterior storage and unknown earlier history remain separately in +that entry premise. + +## 7. Evidence and limits + +The full author packet has f=1, r=P=S=1, w=4, cutoff=1, E=10 and V=4096. +It contains all 512 m=9 Gaussian entries, with odd real signs and zero +imaginary parts. Gaussian phases preserve odd real-plus-imaginary parity; +each C pair has integral sums and bounded components, so this is within the +exact numerical promise even though single basis contributions are halves. + +The expected result uses the retained independent Gaussian **original-frame** +engine on frames []/[239], converting natural coordinate-bit order to the +complete packed order. It sums all Gaussian numerators before testing +integrality and dividing. It does not execute the MOVE's factor/CNOT/phase +word. This avoids incorrectly requiring every individual contribution to be +integral. The literal graph takes 14,495,822 transitions; all 35 heads, +origins, guards, working bodies and opaque exteriors restore. Exactly 4106 +HOME writes occur, all after complete primitive return. The other full HOME +remains unchanged. The rejected arithmetic prefix takes 4,748,143 transitions +with zero HOME writes. + +Seven **parser-only identity** fixtures use encoded cutoff bit lengths through +4097. Their DATA bodies are small codec probes, not claimed legal full native +fields. They execute the same fixed split/repack graph and retain old backing; +they do not stand in for the actual complete packet run. Header-drop and +wrong-HOME controls reuse genuine successful full-core snapshots and mutate +only adapter/return suffixes. Guard-offset monitoring, raw-zero rejection and +an actual corrupted disposable native source complete the six controls. + +The universal all-f composition rests on the source core theorem, local +instruction refinement and exact copy/parse invariants, not finite-test +extrapolation. All five selected assumptions remain. No full selected manifest, +all-word generation, endpoint scaling, source producer/initializer, numerical +reserve producer, nonleaf tariff, rejection cleanup or multiplier is claimed. + +Open next questions: compose this ABI with one actual supplied field producer +and prove its complete grid/width/layout/cutoff bill; or add a source-bound +failure-retirement transformer if retry is required. Neither is implicit in +the supplied formatted input or successful reuse contract. diff --git a/research/source-bound-move-home-primitive/README.md b/research/source-bound-move-home-primitive/README.md new file mode 100644 index 0000000000..ef087bcb9f --- /dev/null +++ b/research/source-bound-move-home-primitive/README.md @@ -0,0 +1,90 @@ +# Actual selected MOVE through one complete HOME field + +This package installs the **unchanged exact selected MOVE24472** as one typed +uniform primitive of the permanent-home dispatcher. The supplied binary body +is six positive Gamma codes `f,r,P,S,w,cutoff`, followed immediately by the +complete packed DATA and B1's outside `|`. Its extent is F=E+V. The result +returns the identical header and complete transformed DATA to the same HOME. + +The native core is pinned at `3a27ab1d302d13b1ce52411f8a174e7a32baab77`; +B1 is pinned at `b4fcc9d64971fdabd0b1d82cfb749d8aac920437`. All runtime +imports are retained locally with exact source pins. The prototype no longer +uses shared checkout paths. See [PROOF.md](PROOF.md) and [SOURCES.json](SOURCES.json). + +The graph copies/splits HEADER and DATA onto 31 distinct private core tapes, +then runs the actual 82,813-instruction core. B's permanent origin is relative +cell 0; native origins are shifted to 2, leaving private guard cell 1 blank. +Successful repacking retires copies and returns all private heads to B origin +0 without erasing `^`. The complete graph has 82,980 states on 35 tapes. +No runtime Python factor callback, decoded integer oracle or replacement core +implements the MOVE. + +The standalone bill is +`128(F+1)+2^24(fV+E+1)`, with history bounded by entry history plus +`1088(F+1)`. B1 still pays its separate O(RKF) full-field gathering/return. +At a fixed admitted leaf cutoff f<=q, the primitive is O_q(F); a large encoded +cutoff still pays all of its E bits. No faster nonleaf rate is asserted. + +## Reproduce + +Python 3.12, standard library only, from the repository root: + +```sh +python3 -I -W error -B research/source-bound-move-home-primitive/verify.py +python3 -I -O -W error -B research/source-bound-move-home-primitive/verify.py +``` + +The result marker is `PASS_SOURCE_BOUND_MOVE_HOME_PRIMITIVE`. `--write` +regenerates RESULT.json. Default execution compares its full scientific +payload. Source bytes authenticate before imports; source bytecode caches +are isolated from the retained inputs. No Git, network, shared source checkout +or full historical suite is needed. + +The full f=1, m=9 packet contains 512 Gaussian entries, with odd real signs +and zero imaginary components. The original-frame Gaussian oracle sums all +numerators before checking integrality: individual half-integral basis terms +are allowed to cancel. It uses frames []/[239], not the core's factor/CNOT +word. E=10, V=4096 and F=4106. The complete run takes **14,495,822 literal +transitions**, writes exactly 4106 selected HOME bits after primitive return, +and preserves another arbitrary same-F source HOME. Every head, permanent +origin, private guard/body and opaque exterior restores. + +The rejected arithmetic prefix takes 4,748,143 transitions with zero HOME +writes. Seven parser-only identity probes cover cutoff bit lengths through +4097 and preserve an explicitly older guide history. Those small DATA bodies +are codec tests, not legal full native fields. + +Six controls detect a dropped header return, wrong-home scatter, wrong guard +offset, arithmetic rejection before HOME mutation, raw-zero capacity treated +as a formatted packet and actual corruption of a disposable native-source +copy. Header/drop and wrong-home controls reuse a genuine completed full-core +snapshot and mutate only suffixes. Wrong guard detection is a test monitor +reporting an attempted forbidden origin write; it is not a compiled runtime +protection. Rejection cleanup/retry is unclaimed. + +## Scientific boundary + +The complete positive six-code packet, common grid, width, packed layout, +cutoff and exact core numerical admission are **supplied caller promises**. +Owned `0^F` is not a packet or an initializer. Earlier history and opaque +storage remain in K_entry; monitored head-span windows do not infer that +complete entry bound. All nine native blocks, P/S spectators, r coefficients +and signed bits remain in DATA throughout. + +This proves one actual primitive/dispatcher ABI composition. It supplies no +complete native supplier, selected source-word generation, caller/initializer +admission, new precision reserve, endpoint scale conversion, faster recurrence +or analytic recovery. All five assumptions and κ=.00363005817 remain. + +## Open next questions + +1. Connect one actual field producer to this exact Gamma/packed ABI and prove + its grid, width, cutoff, layout and complete transport bill. The supplied + entry promise is not that producer. +2. If arithmetic-failure retry is required, compose a source-bound retirement + transformer for the entire adapter/core, retaining public contents and all + prior backing. Successful return alone does not establish rejection reuse. + +Prepared with substantial OpenAI Codex assistance. Source and predecessor +attribution is retained in [NOTICE.md](NOTICE.md) and the unchanged nested +notices. No human or formal-kernel acceptance is claimed. diff --git a/research/source-bound-move-home-primitive/RESULT.json b/research/source-bound-move-home-primitive/RESULT.json new file mode 100644 index 0000000000..1e1b52b4c2 --- /dev/null +++ b/research/source-bound-move-home-primitive/RESULT.json @@ -0,0 +1,373 @@ +{ + "E": 10, + "F": 4106, + "HOME_writes_rejection": 0, + "HOME_writes_success": 4106, + "V": 4096, + "controls": [ + "dropped_header_return", + "wrong_home_return", + "monitor_detects_native_guard_write_over_B_origin", + "arithmetic_rejection_before_HOME_mutation", + "raw_zero_is_not_formatted_packet", + "frozen_native_core_source_corruption" + ], + "core_completed_prefix_steps": 14462894, + "core_graph_sha256": "14f38b15157a9c9cd2828861f6904701a29b1e27507a7e43d60030e1ae4d9238", + "core_locations": 82813, + "fixture": "all odd real signs and zero imaginary; half-integral source-column contributions cancel before the final integrality test", + "graph_states": 82980, + "history_boundary": "K_entry also includes preserved opaque exterior storage and any earlier history; reported head windows do not infer the full entry backing", + "input_sha256": "0705d5d1fc729a47e0da3400d35f660b88b41b643a9a5a1bbb64e9dec4ef15d9", + "marker": "PASS_SOURCE_BOUND_MOVE_HOME_PRIMITIVE", + "monitored_entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 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, + 23 + ], + [ + 17, + 17 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 22 + ], + [ + 23, + 12341 + ] + ], + "monitored_final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 19 + ], + [ + 20, + 32 + ], + [ + 21, + 4119 + ], + [ + 22, + 4120 + ], + [ + 23, + 4121 + ], + [ + 17, + 4115 + ], + [ + 18, + 4116 + ], + [ + 19, + 33 + ], + [ + 20, + 4118 + ], + [ + 21, + 25 + ], + [ + 22, + 4120 + ], + [ + 23, + 2073 + ], + [ + 17, + 2067 + ], + [ + 18, + 32 + ], + [ + 19, + 4117 + ], + [ + 20, + 2070 + ], + [ + 21, + 4119 + ], + [ + 22, + 33 + ], + [ + 23, + 153 + ], + [ + 17, + 2067 + ], + [ + 18, + 1044 + ], + [ + 19, + 2069 + ], + [ + 20, + 2070 + ], + [ + 21, + 2071 + ], + [ + 22, + 2072 + ], + [ + 23, + 2073 + ], + [ + 17, + 1043 + ], + [ + 18, + 1044 + ], + [ + 19, + 1045 + ], + [ + 20, + 4118 + ], + [ + 21, + 29 + ], + [ + 22, + 4120 + ], + [ + 23, + 12341 + ] + ], + "output_sha256": "a4134e195c5e558bd0e48438d662ba6aee71c4f7a56a71bfbb3e064afe56ac22", + "parked_sha256": "ce30cf974a0b7471dcd93af93930713d1e4096ad19057213c0c60b97341b3abb", + "parser_cases": [ + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 20, + "F": 28, + "cutoff_bitlength": 2, + "retained_guide_extent": 85, + "steps": 629 + }, + { + "E": 32, + "F": 40, + "cutoff_bitlength": 8, + "retained_guide_extent": 121, + "steps": 827 + }, + { + "E": 144, + "F": 152, + "cutoff_bitlength": 64, + "retained_guide_extent": 457, + "steps": 2675 + }, + { + "E": 532, + "F": 540, + "cutoff_bitlength": 258, + "retained_guide_extent": 1621, + "steps": 9077 + }, + { + "E": 2066, + "F": 2074, + "cutoff_bitlength": 1025, + "retained_guide_extent": 6223, + "steps": 34388 + }, + { + "E": 8210, + "F": 8218, + "cutoff_bitlength": 4097, + "retained_guide_extent": 24655, + "steps": 135764 + } + ], + "ready_before_scatter_steps": 14475282, + "rejection_steps": 4748143, + "scope": "actual exact selected MOVE24472 primitive; supplied packed entry, cutoff and numerical admission; no initializer or complete caller", + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "successful_steps": 14495822, + "tapes": 35 +} diff --git a/research/source-bound-move-home-primitive/REVIEW-FREEZE.json b/research/source-bound-move-home-primitive/REVIEW-FREEZE.json new file mode 100644 index 0000000000..47d769c575 --- /dev/null +++ b/research/source-bound-move-home-primitive/REVIEW-FREEZE.json @@ -0,0 +1,238 @@ +{ + "status": "independently_reviewed_scoped_result", + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "scope": "actual complete-field exact MOVE primitive; inherited numerical and supplied entry promises retained", + "all_f_universal_proof": "PROOF.md", + "independent_reviews": [ + "review/ROOT-REVIEW.md", + "review/C-REVIEW.md" + ], + "files": [ + { + "path": "FREEZE.json", + "bytes": 1752, + "sha256": "22a53a789d76843647e6b07e3d3cb45b660c742d9ea10895264329e502e5eb8e" + }, + { + "path": "NORMAL.log", + "bytes": 4831, + "sha256": "e6f1509f15647534409019b43074792193594b5953ed6c4ae4144a48bd27afdd" + }, + { + "path": "NOTICE.md", + "bytes": 2093, + "sha256": "b51b8fd0773a1bbe988c8a98d951dc34b175bf56bac772ef65997f1df7ed3842" + }, + { + "path": "OPTIMIZED.log", + "bytes": 4831, + "sha256": "61cc6a0e823089f258b0fe58b5d9584475fe9618175f82e7e504ce840926aa87" + }, + { + "path": "OVERLAP.json", + "bytes": 1799, + "sha256": "bcde513dfaaa4170da5a680c1950827f2bc84f151e059be9f220163fe6f17d16" + }, + { + "path": "PR.md", + "bytes": 3940, + "sha256": "ca27a6e8ba9723e81edaad8ac27e98dfac51fca81becda2d30a22657ddba6506" + }, + { + "path": "PREFLIGHT.md", + "bytes": 3633, + "sha256": "07386a1c142a6b233d8331ff6f58e3f1c2180fab01a948a24bd88df460e2dd4b" + }, + { + "path": "PROOF.md", + "bytes": 13638, + "sha256": "4beaa35f0d6637daa2bafac3fa0a1b7a66a18745dc936e94e3fcb3236f8798c2" + }, + { + "path": "README.md", + "bytes": 4906, + "sha256": "e9268ca3160b4aa75b37c8c4124beba1edb7b8a8a259aa51220f0294fdfeb093" + }, + { + "path": "RESULT.json", + "bytes": 4809, + "sha256": "be101121237cb6ea80fc10c1676e93b0ecf0c06529b3ae126cadde93bcd4c701" + }, + { + "path": "SOURCES.json", + "bytes": 10475, + "sha256": "073e33d01652487c11a7853bff9e4014dc58ad5a7efa7f22117f636f13b9a1cb" + }, + { + "path": "adapter.py", + "bytes": 5353, + "sha256": "04462e141548c6a86c500d40b4aee8c446c539bd9269098d7516fa13400ef099" + }, + { + "path": "inputs/dispatch/NOTICE.md", + "bytes": 2050, + "sha256": "9d39f6596a51aa8717908431017a51e69c3091145b03157087978b8c84073a94" + }, + { + "path": "inputs/dispatch/PROOF.md", + "bytes": 21078, + "sha256": "63f29469fd49751f267db6e26e3494e2bea567fa909d5ebfa2ec9a5924674a4e" + }, + { + "path": "inputs/dispatch/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54" + }, + { + "path": "inputs/native/NOTICE.md", + "bytes": 2852, + "sha256": "7271c647d2d1e7f0f3ef80a6923ff194247eec1a4d8fd7dee4be626310e2026a" + }, + { + "path": "inputs/native/PROOF.md", + "bytes": 16091, + "sha256": "aa7897029c9761fdf96c3336ab37c2827f08b0df29c868e3b2257ecc661ac7b6" + }, + { + "path": "inputs/native/SOURCES.json", + "bytes": 7341, + "sha256": "26d0ef51dda5fa599381f7f31dec4ba3a37f14f63ff9055ad1661dec2d02610c" + }, + { + "path": "inputs/native/move.py", + "bytes": 5497, + "sha256": "42e4293ab59ffa1c99e0dbbd5fded0833a5d726e1e794f0f263ae9a4686587a5" + }, + { + "path": "inputs/native/reference/RECIPE.json", + "bytes": 1798, + "sha256": "96fadb44c3316be93c6c02f50cd2c841a9541d67b98fd94fc47b73fa64dd404c" + }, + { + "path": "inputs/native/reference/SOURCE-FRAMES.json", + "bytes": 151, + "sha256": "58f784587d1f21d6aaa1f6a14932779ff1f24d232496b042240e832939c9010d" + }, + { + "path": "inputs/native/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf" + }, + { + "path": "inputs/native/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "inputs/native/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744" + }, + { + "path": "inputs/native/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50" + }, + { + "path": "inputs/native/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "inputs/native/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33" + }, + { + "path": "inputs/native/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0" + }, + { + "path": "inputs/native/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "inputs/native/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7" + }, + { + "path": "inputs/native/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "inputs/native/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "inputs/native/reference/translation/NOTICE.md", + "bytes": 1201, + "sha256": "24f5e9957fcd8f6cfdc021ff5bc91bf89e50587997e2a2cb18053949c0e0d205" + }, + { + "path": "inputs/native/reference/translation/reference/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73" + }, + { + "path": "inputs/native/reference/translation/reference/reverse.py", + "bytes": 6649, + "sha256": "4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245" + }, + { + "path": "inputs/native/reference/translation/translate.py", + "bytes": 7703, + "sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd" + }, + { + "path": "machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + }, + { + "path": "oracle.py", + "bytes": 1942, + "sha256": "c31ca791d15cbb44873073ac4e529924bfb9dabd35ff72b1025c866cb2993fdd" + }, + { + "path": "review/C-REVIEW.md", + "bytes": 6806, + "sha256": "8bf0a53061bb5e38e7465fd3cb14c02e8bce92f092fce4caa7da33278b79810c" + }, + { + "path": "review/PUBLICATION-REPLAY.txt", + "bytes": 4831, + "sha256": "cb583affd51901b44ad5645bc0276a67d6319ffef76cfbf54dfc5a341654f74e" + }, + { + "path": "review/RESULT.json", + "bytes": 1558, + "sha256": "55b7ee7dd6f80ac00cc8137cdb7cac5e788d094a01076c16de14d07c1df4ab4f" + }, + { + "path": "review/ROOT-REVIEW.md", + "bytes": 2381, + "sha256": "a2591016d95fe6e95e1fee28f243e648c2003c029918b4b3144c4642473cab8e" + }, + { + "path": "review/SOURCE-BINDING.json", + "bytes": 6517, + "sha256": "79013c43107f5d212ac41cde6e324c69ba41175530fb3d0befaf7cd8e1506300" + }, + { + "path": "review/check_adapter_root.py", + "bytes": 6558, + "sha256": "3ef06776b67153c5618e8ace6240c7c76efb3e7bca24b26f8b3146234a19d688" + }, + { + "path": "verify.py", + "bytes": 7465, + "sha256": "2f04f1301f369c666acd8c88ce952c572c946672784ccbffbd147581b7e3bb49" + } + ], + "lead_edits": "PR title/credit and independent-review summary; corrected one source hash transcription and limited an unsupported relocation-necessity sentence in copied review. Runtime unchanged." +} diff --git a/research/source-bound-move-home-primitive/SOURCES.json b/research/source-bound-move-home-primitive/SOURCES.json new file mode 100644 index 0000000000..c3736f92f9 --- /dev/null +++ b/research/source-bound-move-home-primitive/SOURCES.json @@ -0,0 +1,221 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "local": "inputs/native/move.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/move.py", + "bytes": 5497, + "sha256": "42e4293ab59ffa1c99e0dbbd5fded0833a5d726e1e794f0f263ae9a4686587a5", + "git_blob": "3c11397a02d2a52e3e3d690bce1ebfe067b06c6c" + }, + { + "local": "inputs/native/SOURCES.json", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/SOURCES.json", + "bytes": 7341, + "sha256": "26d0ef51dda5fa599381f7f31dec4ba3a37f14f63ff9055ad1661dec2d02610c", + "git_blob": "8a2db1259a94dd5e863d8e95922ef33ef93e8751" + }, + { + "local": "inputs/native/NOTICE.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/NOTICE.md", + "bytes": 2852, + "sha256": "7271c647d2d1e7f0f3ef80a6923ff194247eec1a4d8fd7dee4be626310e2026a", + "git_blob": "0a756baa4d0aea22c1db64c9962d2082d09fefce" + }, + { + "local": "inputs/native/PROOF.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/PROOF.md", + "bytes": 16091, + "sha256": "aa7897029c9761fdf96c3336ab37c2827f08b0df29c868e3b2257ecc661ac7b6", + "git_blob": "8cdce2234c3a3f3a05b2aaeabe8bf7a222c6a5f2" + }, + { + "local": "inputs/native/reference/linear/linear.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/linear/linear.py", + "bytes": 13102, + "sha256": "d56704082b82e37d4a360b8aad7e0af63499f4160c6bbcfd338804453c46fa33", + "git_blob": "6aad40a6c47ed4415917c86fabbd5227a3819a41" + }, + { + "local": "inputs/native/reference/linear/inputs/controller_reference.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/linear/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "local": "inputs/native/reference/linear/NOTICE.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/linear/NOTICE.md", + "bytes": 2180, + "sha256": "2ac2051c0fbedfd9d11348493456bf479dbdd3104a4e106c8bf36251a72b6a50", + "git_blob": "3a3030f23df347c1e45ddf92d2083f89ed16cc67" + }, + { + "local": "inputs/native/reference/phase/phase.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/phase/phase.py", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "git_blob": "d48978145821fc4a62d534bef2bef9449bda883a" + }, + { + "local": "inputs/native/reference/phase/inputs/controller_reference.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/phase/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "local": "inputs/native/reference/RECIPE.json", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/RECIPE.json", + "bytes": 1798, + "sha256": "96fadb44c3316be93c6c02f50cd2c841a9541d67b98fd94fc47b73fa64dd404c", + "git_blob": "ea2bc6909e02d8aa61e170d65bb707da7279d0ab" + }, + { + "local": "inputs/native/reference/phase/NOTICE", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/phase/NOTICE", + "bytes": 808, + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0", + "git_blob": "7a1f1da9c59d40b1e72905fee5344a8db9ca4353" + }, + { + "local": "inputs/native/reference/leaf/leaf.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/leaf/leaf.py", + "bytes": 17526, + "sha256": "bb46c1a55f1119957a52cd61f2cd957f3f7ad1e9b818c54a852bde09a0773744", + "git_blob": "bdcc80cbd8b64c601e6d69b7d25ece444b8b1ae2" + }, + { + "local": "inputs/native/reference/leaf/inputs/controller_reference.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/leaf/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "local": "inputs/native/reference/leaf/NOTICE.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/leaf/NOTICE.md", + "bytes": 1900, + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf", + "git_blob": "71c5f6dae2c799ce5d76c544e98d1ee7c52ef76c" + }, + { + "local": "inputs/native/reference/translation/translate.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/translation/translate.py", + "bytes": 7703, + "sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd", + "git_blob": "5e1149f8ab45e0d5b4ecd963674ff8659d7f014b" + }, + { + "local": "inputs/native/reference/translation/reference/reverse.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/translation/reference/reverse.py", + "bytes": 6649, + "sha256": "4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245", + "git_blob": "60fce51dd8c3336e2bcf2873df254190e2203e14" + }, + { + "local": "inputs/native/reference/translation/reference/inputs/controller_reference.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/translation/reference/inputs/controller_reference.py", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72" + }, + { + "local": "inputs/native/reference/translation/NOTICE.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/translation/NOTICE.md", + "bytes": 1201, + "sha256": "24f5e9957fcd8f6cfdc021ff5bc91bf89e50587997e2a2cb18053949c0e0d205", + "git_blob": "903e332da2844843fbb1ad716b6d470f175e8de9" + }, + { + "local": "inputs/native/reference/source/clifford_exact.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/source/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "local": "inputs/native/reference/source/native_verify.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/source/native_verify.py", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c" + }, + { + "local": "inputs/dispatch/tape_graph.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7" + }, + { + "local": "inputs/dispatch/NOTICE.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/NOTICE.md", + "bytes": 2050, + "sha256": "9d39f6596a51aa8717908431017a51e69c3091145b03157087978b8c84073a94", + "git_blob": "23bbd0b1c82915aa9426dd12dda5206a3c4874a1" + }, + { + "local": "inputs/dispatch/PROOF.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/PROOF.md", + "bytes": 21078, + "sha256": "63f29469fd49751f267db6e26e3494e2bea567fa909d5ebfa2ec9a5924674a4e", + "git_blob": "7719ddc99032bd29fb46bc986c89b9741120184d" + }, + { + "local": "inputs/native/reference/SOURCE-FRAMES.json", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "3a27ab1d302d13b1ce52411f8a174e7a32baab77", + "path": "research/literal-selected-move-join/reference/SOURCE-FRAMES.json", + "bytes": 151, + "sha256": "58f784587d1f21d6aaa1f6a14932779ff1f24d232496b042240e832939c9010d", + "git_blob": "478d9edddea642447dd14a931835c0208d7278e4" + } + ] +} diff --git a/research/source-bound-move-home-primitive/adapter.py b/research/source-bound-move-home-primitive/adapter.py new file mode 100644 index 0000000000..10606f87dc --- /dev/null +++ b/research/source-bound-move-home-primitive/adapter.py @@ -0,0 +1,131 @@ +"""Paid six-Gamma||DATA ABI for actual MOVE24472. Apache-2.0; Codex-assisted. + +Python constructors run only offline. Runtime is local Graph transitions. +""" +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') +NATIVE=HERE/'inputs/native' +B1=HERE/'inputs/dispatch/tape_graph.py' +for pin in json.loads((HERE/'SOURCES.json').read_text())['files']: + raw=(HERE/pin['local']).read_bytes() + if len(raw)!=pin['bytes'] or sha256(raw).hexdigest()!=pin['sha256']: + raise ValueError('frozen source drift: '+pin['local']) + + +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 + + +if sha256(B1.read_bytes()).hexdigest()!='7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54': + raise ValueError('B1 graph source drift') +D=load('home_move_dispatch',B1) +C=load('home_move_native',NATIVE/'move.py') +CORE_BASE,GUIDE,TAPES=3,34,35 +HOME_OWNERS=(('native-occurrence',24472,415),('parked-source',0)) + + +@cache +def core(): + code,alphabet=C.compile_move() + if len(code)!=82813 or alphabet!=('_','0','1','|'): + raise ValueError('changed actual selected table') + 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): + 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