diff --git a/research/source-bound-signed-home-add/AUTHOR-CHECKSUMS.sha256 b/research/source-bound-signed-home-add/AUTHOR-CHECKSUMS.sha256 new file mode 100644 index 0000000000..b522dd3b34 --- /dev/null +++ b/research/source-bound-signed-home-add/AUTHOR-CHECKSUMS.sha256 @@ -0,0 +1,17 @@ +3505fbd0eb9aa6a881d2d142d666d8bd62c5152a42d45233f88225ab20f2ef09 FREEZE.json +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 NORMAL.log +8d46ade764824f03c98a4a1319521e946158f9c7aaa4638d94c656133e18b093 NOTICE.md +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 OPTIMIZED.log +4eff9eff88b502de439e37c0359c8d9a167bb1ddc2ec6c288526b1d117bb06b3 OVERLAP.json +43883dbcedfd02a857fedb9bfca446337ce5e089cf61ef8f3d67db445b93e775 PR.md +10928c3c59885cb61173aefc6bf262c61fa74288ea7b65f9ac328f0988a89881 PREFLIGHT.md +08c8b9015a32a164ff09686dd044fb8d940d1a902bf6c21f9bceb2609051d7d9 PROOF.md +ece3f40bb226516492d0b2b26790d50c84392d5ac42fb673171035287031fe24 README.md +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 RESULT.json +c82c95ddc011e6cea480435557e57165c3962b522cdbb3ea41ccaaadb026fa2e SOURCE-CONTACTS.json +7da540e288b8872cdeb7ca476200daafff2257c9ad4aaf582c9aff1ac37ec233 SOURCES.json +5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b add.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee inputs/machine.py +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055 inputs/selected-application-review.md +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 inputs/tape_graph.py +aa1782a734254305814865a13a6326f3739741af80bb442e760a9047efdfa7de verify.py diff --git a/research/source-bound-signed-home-add/AUTHOR-FREEZE.json b/research/source-bound-signed-home-add/AUTHOR-FREEZE.json new file mode 100644 index 0000000000..3506f7e6fd --- /dev/null +++ b/research/source-bound-signed-home-add/AUTHOR-FREEZE.json @@ -0,0 +1,71 @@ +{ + "add_sha256": "5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b", + "b1_commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "Uniform exact exterior +/-1 primitive on supplied matching valid complete six-Gamma/packed fields with common frame/grid; all header comparison, physical width decoding and successful restoration are charged.", + "commands": [ + { + "argv": [ + "python3", + "-I", + "-W", + "error", + "-B", + "verify.py", + "--source-repo", + "/workspace/scratch/92c9920affc2/repo" + ], + "cwd": "research/source-bound-signed-home-add", + "exit_code": 0, + "log": "NORMAL.log" + }, + { + "argv": [ + "python3", + "-I", + "-O", + "-W", + "error", + "-B", + "verify.py" + ], + "cwd": "research/source-bound-signed-home-add", + "exit_code": 0, + "log": "OPTIMIZED.log" + } + ], + "complete_field_cases": 22, + "complete_field_successes": 16, + "complete_field_transitions": 3886680, + "controls": [ + "wrong_fixed_coefficient_sign", + "mismatched_equal_length_headers", + "minimum_source_subtraction_cancellation", + "even_f_exterior_minus_one_not_tensor_phase_component_boundary" + ], + "frozen_at_utc": "2026-11-13 10:37:14 UTC", + "graph_states_each_sign": 91, + "late_overflow_HOME_preserving_rejections": 6, + "raw_native_identity_fixtures": 2, + "separate_model_review": { + "path": "root-work/signed-add-review", + "reported_exhaustive_component_pairs": 10912, + "reported_fault_control": "missing carry", + "reported_full_field_component_counts": [ + 4096, + 12288 + ], + "reported_late_overflows": 2, + "scope": "Separate root sparse interpreter; not a human or kernel acceptance. Retention is managed by root.", + "widths": "2..6" + }, + "tapes": 6, + "unclaimed": [ + "Typed packet initialization/production", + "Full compiler SourceRow/OwnedBank address generation", + "Actual equal-F view supplier or complete bank lifetime", + "Rank2 MOVE28141", + "All-word selected compiler or native supplier", + "New kappa or discharge of any of the five framework assumptions" + ] +} diff --git a/research/source-bound-signed-home-add/CHECKSUMS.sha256 b/research/source-bound-signed-home-add/CHECKSUMS.sha256 new file mode 100644 index 0000000000..4b1e401319 --- /dev/null +++ b/research/source-bound-signed-home-add/CHECKSUMS.sha256 @@ -0,0 +1,17 @@ +ddc3d436dfe5f312debe8dd6d6ffbb64c6cf4d386ae03add01074ae322a6321c FREEZE.json +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 NORMAL.log +8d46ade764824f03c98a4a1319521e946158f9c7aaa4638d94c656133e18b093 NOTICE.md +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 OPTIMIZED.log +4eff9eff88b502de439e37c0359c8d9a167bb1ddc2ec6c288526b1d117bb06b3 OVERLAP.json +1aa665f371a03c081092e6c8ecf0ae520bd0a6c04e8ca14d77e89fc1236b2031 PR.md +0b6a0c2c3bfa2e12511a56aab10d0d899080991a3223d64fdc36d2b2bf97bbb6 PREFLIGHT.md +84e9184ac4e53816b2c622e467be76eb08d4775bb4004c854c52a604e21061fc PROOF.md +32883cda59087487ffecc18824cb55bd2528c6e54e7d5dc14c3256ea38937682 README.md +9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642 RESULT.json +c82c95ddc011e6cea480435557e57165c3962b522cdbb3ea41ccaaadb026fa2e SOURCE-CONTACTS.json +7da540e288b8872cdeb7ca476200daafff2257c9ad4aaf582c9aff1ac37ec233 SOURCES.json +5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b add.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee inputs/machine.py +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055 inputs/selected-application-review.md +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 inputs/tape_graph.py +aa1782a734254305814865a13a6326f3739741af80bb442e760a9047efdfa7de verify.py diff --git a/research/source-bound-signed-home-add/FREEZE.json b/research/source-bound-signed-home-add/FREEZE.json new file mode 100644 index 0000000000..a78dda8fe4 --- /dev/null +++ b/research/source-bound-signed-home-add/FREEZE.json @@ -0,0 +1,78 @@ +{ + "add_sha256": "5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b", + "b1_commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "Uniform exact exterior +/-1 primitive on supplied matching valid complete six-Gamma/packed fields with common frame/grid; all header comparison, physical width decoding and successful restoration are charged.", + "commands": [ + { + "argv": [ + "python3", + "-I", + "-W", + "error", + "-B", + "verify.py", + "--source-repo", + "/workspace/scratch/92c9920affc2/repo" + ], + "cwd": "research/source-bound-signed-home-add", + "exit_code": 0, + "log": "NORMAL.log" + }, + { + "argv": [ + "python3", + "-I", + "-O", + "-W", + "error", + "-B", + "verify.py" + ], + "cwd": "research/source-bound-signed-home-add", + "exit_code": 0, + "log": "OPTIMIZED.log" + } + ], + "complete_field_cases": 22, + "complete_field_successes": 16, + "complete_field_transitions": 3886680, + "controls": [ + "wrong_fixed_coefficient_sign", + "mismatched_equal_length_headers", + "minimum_source_subtraction_cancellation", + "even_f_exterior_minus_one_not_tensor_phase_component_boundary" + ], + "frozen_at_utc": "2026-11-13 10:37:14 UTC", + "graph_states_each_sign": 91, + "late_overflow_HOME_preserving_rejections": 6, + "raw_native_identity_fixtures": 2, + "separate_model_review": { + "path": "root-work/signed-add-review", + "reported_exhaustive_component_pairs": 10912, + "reported_fault_control": "missing carry", + "reported_full_field_component_counts": [ + 4096, + 12288 + ], + "reported_late_overflows": 2, + "scope": "Separate root sparse interpreter; not a human or kernel acceptance. Retention is managed by root.", + "widths": "2..6" + }, + "tapes": 6, + "unclaimed": [ + "Typed packet initialization/production", + "Full compiler SourceRow/OwnedBank address generation", + "Actual equal-F view supplier or complete bank lifetime", + "Rank2 MOVE28141", + "All-word selected compiler or native supplier", + "New kappa or discharge of any of the five framework assumptions" + ], + "publication_correction": { + "record": "review/MOVE-BOOLEAN-CORRECTION.json", + "original_freeze": "AUTHOR-FREEZE.json", + "original_checksums": "AUTHOR-CHECKSUMS.sha256", + "code_and_receipt_unchanged": true + }, + "proof_sha256": "84e9184ac4e53816b2c622e467be76eb08d4775bb4004c854c52a604e21061fc" +} diff --git a/research/source-bound-signed-home-add/NORMAL.log b/research/source-bound-signed-home-add/NORMAL.log new file mode 100644 index 0000000000..a92f03544b --- /dev/null +++ b/research/source-bound-signed-home-add/NORMAL.log @@ -0,0 +1,1708 @@ +{ + "cases": [ + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "365c7dd4cc5d0f9f362eef2ae23b44e09565e89e46dbaee85dce71fdbcdaaf80", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "e57302c0c7eee8b47d9e9bc4db53cb2cc74c0a5b0261d8db83da6830558243c0", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "907f235c1acce7e3079f86e53d4bd62677e88ab07127b18f1cbbe85dcc4d61be", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "beeba5fe1b60599d66b99389aa014fad4e04fba4525baf2dfbedb7bfb89c9aff", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "fc5bc6d7101dfd498724c0b58ea0066b176544d6c0079caed388bf03d48201aa", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "d305f1e9575f350f0e47fe12cfc9b3e92d52b0dee2232a673b4780a9c946d02f", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "b9231be7c5817dc1ebd031ceeb72b36ea830fe55c57ed0a5e36a329a9abd11b8", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "65d67b81b1df9c650e803bd8ae9381e927a0b7bf97907a438657a4b03e850045", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b419d3755e65b8462ca58b8284c0ef4d9bdf49ec6f7fe0cb60edff71259253a4", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "657bd69aeefdbb3caa5f3de6b50e7b9809d832b3f07ee5c0511e2600256faa87", + "states": 91, + "steps": 98515 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "9f655ce3e89f74172729e1274cf611dae04c2c7d770975b6f1cbb107f32a375b", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b80f883a61b69e38bf7203d92d044b5e5a169c2d56bb8227d1c50608942481a2", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "f858911735946c9f1855cd3015b4f8c831f8bd924815e7cfb8e2d2b636877567", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "2679b556160ff6a79bfe7514dd337e22ab64dde5c1f25072892145921dc91649", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "3929e8c193d7c0eb3374324e0adc9ebd6fb9cc6b65a12d8523159626d183b2b2", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "63f7ba969bdff4a407b94d7d31cb8f2cdfa38d946700cbaa34991182662995d6", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "ebae0a4e69c14d6c617410cf264229314bdc6c134c59682608cd3e74e4102adc", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "c952f9a76fd5d866a47d5208152c12a3ed0aedfea92b0bcb66c45eb1fe461e8f", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "f0d8f2272df041fae5b9f8a9db1c9e416136442a3f04be73fc5cfc03f072367b", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "4d7d343e5207eb69dccf3bfb9b52592f7cea781a724f66d99ec1db577c29ec5c", + "states": 91, + "steps": 98515 + } + ], + "contacts": [ + [ + 28041, + [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + ], + [ + 28129, + [ + "ADD", + 1526, + 728, + "-1", + 601 + ] + ], + [ + 28135, + [ + "ADD", + 1526, + 729, + "-1", + 601 + ] + ], + [ + 28139, + [ + "ADD", + 1526, + 730, + "-1", + 601 + ] + ], + [ + 28159, + [ + "ADD", + 1515, + 1526, + "1", + 470 + ] + ] + ], + "controls": [ + "wrong_fixed_coefficient_sign", + "mismatched_equal_length_headers", + "minimum_source_subtraction_cancellation", + "even_f_exterior_minus_one_not_tensor_phase_component_boundary" + ], + "history_boundary": "K_entry includes opaque exterior storage and earlier history; monitored windows do not infer it.", + "marker": "PASS_SOURCE_BOUND_SIGNED_HOME_ADD", + "native_identity_fixtures": [ + { + "K": 2, + "body_entry": "already_reserved_and_typed", + "event_index": 28041, + "operand_indices": [ + 0, + 1 + ], + "operation": "SUB", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 1349 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 86286, + "tag_relabel_graph_identical": true + }, + { + "K": 3, + "body_entry": "already_reserved_and_typed", + "event_index": 28159, + "operand_indices": [ + 1, + 2 + ], + "operation": "ADD", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 0 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1515, + 28153, + 39073 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 102714, + "tag_relabel_graph_identical": true + } + ], + "scope": "fixed \u00b11 source contacts, same valid \u03936 headers/common grid; producer, rank2 MOVE and complete lifetime remain outside scope", + "tapes": 6 +} diff --git a/research/source-bound-signed-home-add/NOTICE.md b/research/source-bound-signed-home-add/NOTICE.md new file mode 100644 index 0000000000..3f4d72ffe0 --- /dev/null +++ b/research/source-bound-signed-home-add/NOTICE.md @@ -0,0 +1,32 @@ +# Attribution + +New six-Gamma/packed exact ±1 ABI, literal graph, source-contact checks and +proof are Apache-2.0, with substantial OpenAI Codex assistance. Generic binary +addition, two's-complement subtraction, Gamma coding and unary guides are +classical; no new arithmetic algorithm is claimed. + +B1 atb4fcc9d64971fdabd0b1d82cfb749d8aac920437 supplies the unchanged Graph +constructor and permanent-home routing. The literal verifier interpreter is +reused from the preceding source-bound MOVE/HOME package, frozen under +manifest efda264fee073edc344a0d516760be28ca8dea6988d64304d846864a9d82678f. +Both are retained byte-for-byte with hashes. Their earlier source-codec, +integer-compiler, live-role and physical-controller credit remains effective. + +CubeJerry/Jerry Chen #6990 supplies larger exact/rounded fixed-rational ADD, +cancellation and full lifecycle on a coded Controller boundary. Nick Petalas +#7268 reduces its signed-residue graph. Both retain DreamingOfClouds' +#6936/#6937 and canonical signed-stream, scalar and one-carry lineage, +including #3094. Their algorithms and source contracts are not claimed anew. +The selected #7000 word, #7426 retained archive/source witness, native/owned +and common-grid lineage remains credited. The five actual contacts preserve +their original coefficients, charts and paid-word context. +The exact main-e545 selected application review, sections2 and4, supplies +the current all-column scalar convention: exterior rational coefficients +remain fixed while native phases lift. Its complete source is retained and +pinned in SOURCES.json; no older selected construction is substituted. + +This does not erase/rebirth a live bank or claim #7389's distinct later-word +semantics. Nor does #6896's historical residue/index bank capacity instantiate +the required header producer. Fresh #7484/#7485/#7486 are separate later-word +algebraic/rank scopes. No whole caller, multiplier, new κ or human/kernel +acceptance is asserted. diff --git a/research/source-bound-signed-home-add/OPTIMIZED.log b/research/source-bound-signed-home-add/OPTIMIZED.log new file mode 100644 index 0000000000..a92f03544b --- /dev/null +++ b/research/source-bound-signed-home-add/OPTIMIZED.log @@ -0,0 +1,1708 @@ +{ + "cases": [ + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "365c7dd4cc5d0f9f362eef2ae23b44e09565e89e46dbaee85dce71fdbcdaaf80", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "e57302c0c7eee8b47d9e9bc4db53cb2cc74c0a5b0261d8db83da6830558243c0", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "907f235c1acce7e3079f86e53d4bd62677e88ab07127b18f1cbbe85dcc4d61be", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "beeba5fe1b60599d66b99389aa014fad4e04fba4525baf2dfbedb7bfb89c9aff", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "fc5bc6d7101dfd498724c0b58ea0066b176544d6c0079caed388bf03d48201aa", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "d305f1e9575f350f0e47fe12cfc9b3e92d52b0dee2232a673b4780a9c946d02f", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "b9231be7c5817dc1ebd031ceeb72b36ea830fe55c57ed0a5e36a329a9abd11b8", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "65d67b81b1df9c650e803bd8ae9381e927a0b7bf97907a438657a4b03e850045", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b419d3755e65b8462ca58b8284c0ef4d9bdf49ec6f7fe0cb60edff71259253a4", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "657bd69aeefdbb3caa5f3de6b50e7b9809d832b3f07ee5c0511e2600256faa87", + "states": 91, + "steps": 98515 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "9f655ce3e89f74172729e1274cf611dae04c2c7d770975b6f1cbb107f32a375b", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b80f883a61b69e38bf7203d92d044b5e5a169c2d56bb8227d1c50608942481a2", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "f858911735946c9f1855cd3015b4f8c831f8bd924815e7cfb8e2d2b636877567", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "2679b556160ff6a79bfe7514dd337e22ab64dde5c1f25072892145921dc91649", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "3929e8c193d7c0eb3374324e0adc9ebd6fb9cc6b65a12d8523159626d183b2b2", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "63f7ba969bdff4a407b94d7d31cb8f2cdfa38d946700cbaa34991182662995d6", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "ebae0a4e69c14d6c617410cf264229314bdc6c134c59682608cd3e74e4102adc", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "c952f9a76fd5d866a47d5208152c12a3ed0aedfea92b0bcb66c45eb1fe461e8f", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "f0d8f2272df041fae5b9f8a9db1c9e416136442a3f04be73fc5cfc03f072367b", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "4d7d343e5207eb69dccf3bfb9b52592f7cea781a724f66d99ec1db577c29ec5c", + "states": 91, + "steps": 98515 + } + ], + "contacts": [ + [ + 28041, + [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + ], + [ + 28129, + [ + "ADD", + 1526, + 728, + "-1", + 601 + ] + ], + [ + 28135, + [ + "ADD", + 1526, + 729, + "-1", + 601 + ] + ], + [ + 28139, + [ + "ADD", + 1526, + 730, + "-1", + 601 + ] + ], + [ + 28159, + [ + "ADD", + 1515, + 1526, + "1", + 470 + ] + ] + ], + "controls": [ + "wrong_fixed_coefficient_sign", + "mismatched_equal_length_headers", + "minimum_source_subtraction_cancellation", + "even_f_exterior_minus_one_not_tensor_phase_component_boundary" + ], + "history_boundary": "K_entry includes opaque exterior storage and earlier history; monitored windows do not infer it.", + "marker": "PASS_SOURCE_BOUND_SIGNED_HOME_ADD", + "native_identity_fixtures": [ + { + "K": 2, + "body_entry": "already_reserved_and_typed", + "event_index": 28041, + "operand_indices": [ + 0, + 1 + ], + "operation": "SUB", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 1349 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 86286, + "tag_relabel_graph_identical": true + }, + { + "K": 3, + "body_entry": "already_reserved_and_typed", + "event_index": 28159, + "operand_indices": [ + 1, + 2 + ], + "operation": "ADD", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 0 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1515, + 28153, + 39073 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 102714, + "tag_relabel_graph_identical": true + } + ], + "scope": "fixed \u00b11 source contacts, same valid \u03936 headers/common grid; producer, rank2 MOVE and complete lifetime remain outside scope", + "tapes": 6 +} diff --git a/research/source-bound-signed-home-add/OVERLAP.json b/research/source-bound-signed-home-add/OVERLAP.json new file mode 100644 index 0000000000..520eb12533 --- /dev/null +++ b/research/source-bound-signed-home-add/OVERLAP.json @@ -0,0 +1,25 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "scope": "Bounded preflight, not a universal novelty claim; classical arithmetic is credited. The delta is the complete six-Gamma/packed-DATA permanent-HOME ABI for five selected fixed-sign contacts.", + "queries": [ + {"terms": "Gamma ADD literal", "public_pr_count": 30, "incomplete_results": false}, + {"terms": "Gamma signed addition", "public_pr_count": 3, "incomplete_results": false} + ], + "predecessors": [ + {"pr": 6990, "head": "38cd824c60f2bb5c6f2603f848a9487cb3a57965", "credit": "Compact rounded fixed-rational ADD, signed numerator cancellation and complete coded-Controller lifecycle; different ABI and broader arithmetic."}, + {"pr": 7268, "head": "618ff7af4ac85c63ee2c39acc69bf763ed35b60a", "credit": "Reverse-Horner compact rounded ADD residue control; different coded-Controller boundary."}, + {"pr": 6896, "head": "0ca312ed12585a1dc56bcb3d90354f8c6307dc28", "distinction": "Historical residue/index Word capacity; no six-Gamma current packet producer."}, + {"pr": 7389, "head": "50ad6777539c9ad3794989259f2bd081f1eb66be", "distinction": "Zero rebirth modifies a different later word; this primitive preserves live owned semantics."} + ], + "fresh_bodies_read": [ + {"pr": 7484, "head": "d1776925456ea254746ffcb61496cf31b5d94f55", "distinction": "Later-word bank1533 early recovery and fixed chart rank."}, + {"pr": 7485, "head": "6f290cb02765b54f5f92c155eb963108853b3677", "distinction": "Later-word role235 chart549 bypass."}, + {"pr": 7486, "head": "54b570cc4697091319ee4e5ab2d91587f3f9684d", "distinction": "Later-word signed idle-pair host-rank obstruction."}, + {"pr": 7487, "head": "080c7b23ed897b9b4d52ba7cb2fb92336524dddb", "distinction": "Later-word J8 odd-return fixed signed-host rank obstruction."} + ], + "exclusions": [ + "No general arithmetic novelty or superiority over the rounded rational packages.", + "No raw-zero typed initializer, packet/view producer or full compiler address supplier.", + "No rank2 MOVE28141, complete lifetime/caller, all-word execution, kappa improvement or assumption discharge." + ] +} diff --git a/research/source-bound-signed-home-add/PR-DESCRIPTION.md b/research/source-bound-signed-home-add/PR-DESCRIPTION.md new file mode 100644 index 0000000000..9adf58c688 --- /dev/null +++ b/research/source-bound-signed-home-add/PR-DESCRIPTION.md @@ -0,0 +1,79 @@ +# Implement exact selected ADD and SUB contacts on packed HOME fields with paid width decoding and restoration + +## Result and relevance + +This package supplies a concrete signed arithmetic primitive for the +compiler's permanent HOME interface. Each uniform graph has 91 states and +six tapes and computes target plus or minus source across complete supplied +six-Gamma/packed-DATA fields. It physically decodes the fifth code's width, +visits every component, preserves source/header values, and restores all +successful working heads and private bodies before returning the target to +its original HOME. On the admitted domain only true completed signed +overflow rejects, before any HOME scatter. + +The standalone bounds are `4096(F+1)` transitions and historical increment +`8(F+2)`. Encoded cutoff inspection, width preparation, rereads, all seeks, +carry work, returns and retirement are included. B1's separate delivery and +retained earlier history remain charged. + +## Exact source binding and novelty + +Canonical base is `e54523517d0f03e58352e647c403a5af3e525a57`. +Selected #7000 bank 1526 has four -1 contacts at events 28041, 28129, 28135 +and 28139 and a +1 contact into bank 1515 at event 28159. The compact witness +pins their complete source archive. The exact selected application review, +sections 2 and 4, establishes that these exterior coefficients remain -1/+1 +for every column multiplicity; only native phases lift with f. + +Binary carries are classical. #6990 and #7268 already supply broader rounded +rational arithmetic in a different coded-controller interface. The new +result is the literal paid packed/HOME interface, precise source-contact +binding, and complete successful lifecycle. It uses the preceding +[permanent HOME dispatcher](https://github.com/CubeJerry/integer-mult-bounds/commit/b4fcc9d64971fdabd0b1d82cfb749d8aac920437) +and [MOVE/HOME interface](https://github.com/CubeJerry/integer-mult-bounds/commit/13c29e2df66ba46402d4da5f1d2489ebf333e5fe), +with the exact required source files retained and authenticated locally. + +## Reproduction and independent checks + +```sh +python3 -I -W error -B research/source-bound-signed-home-add/verify.py +python3 -I -O -W error -B research/source-bound-signed-home-add/verify.py +python3 -I -W error -B research/source-bound-signed-home-add/review/check_signed_add_root.py +``` + +Expected markers are `PASS_SOURCE_BOUND_SIGNED_HOME_ADD` and +`PASS_ROOT_SIGNED_HOME_ADD_REVIEW`. The author corpus covers 22 complete +fields, 16 successes, six late overflows and two qualified raw-native owner +identity fixtures. Optional `--source-repo /path/to/repo` authenticates and +re-extracts the entire source word and selected contacts read-only; this was +executed during review. Wrong sign, unequal headers, signed-minimum +cancellation and an even-f exterior-sign probe are distinguished. + +A separate sparse interpreter and integer oracle exhaust 10,912 component +pairs and execute six fresh complete fields, including 12,288 components and +a 257-bit cutoff. They check private restoration, opaque exteriors, late +HOME-preserving overflow and a missing-carry mutation. Unit component tests +are explicitly separated from full geometry runs. Receipts and the review +are included. This is AI-assisted independent implementation review, not a +human or formal-kernel acceptance claim. + +## Limits and next obligations + +The contract supplies valid matching geometry, common grid and actual frame, +physically distinct operands, and live typed packets. Raw-zero initialization, +actual source/view production, equal-F transport, rank-two owned MOVE28141 +and complete bank/caller admission remain open. The identity fixtures enter +with owned packets already reserved; they do not construct full compiler +SourceRow/OwnedBank addresses or establish selected productive width. No +private cleanup or retry after rejection is claimed. + +**No new kappa.** All five global framework assumptions remain; the accepted +conditional exponent is still `0.00363005817`. This package supplies one +concrete interface primitive and does not alter the selected certificate. + +## Credit + +Prepared for @CubeJerry with substantial OpenAI Codex/Astra/Sol assistance. +Credit the authors of #7000, #6990, #7268 and #7423, the pinned native source +lineage, and the preceding @CubeJerry HOME/MOVE packages. Exact source and +license records are in `SOURCES.json`, `SOURCE-CONTACTS.json` and `NOTICE.md`. diff --git a/research/source-bound-signed-home-add/PR.md b/research/source-bound-signed-home-add/PR.md new file mode 100644 index 0000000000..ad2f3c42e2 --- /dev/null +++ b/research/source-bound-signed-home-add/PR.md @@ -0,0 +1,46 @@ +# Execute selected ±1 scalar contacts on packed HOME fields (no κ) + +The new scientific ADD/SUB graphs operate on complete matching six-Gamma||DATA +fields through B1. They physically decode w, walk every signed component, +preserve source/header values and return the target to its original HOME. +Each uses91 states and6 tapes. Generic carries are classical; the result is +the complete paid ABI and precise selected source-contact binding. + +The exact contacts are SUBs28041/28129/28135/28139 and ADD28159 in selected +#7000 bank1526's lifetime. Archive hashes and tokens are retained; optional +--source-repo re-extracts the complete source hashes and all five events. +The exact main-e545 #7000 application review, sections2/4, is retained and +pinned: exterior -1/+1 coefficients remain unchanged at every f; only native +phases lift with f. A component-boundary even-f control detects the erroneous +choice (-1)^f, separately from complete-field physical width decoding. +Standalone time is at most4096(F+1), with retained increment at most8(F+2). +B1 still pays O(RKF) delivery. Width decoding is O(w) via the binary-prefix +sum; every seek, source reread, return, reset and retirement is included. + +```sh +python3 -I -W error -B research/source-bound-signed-home-add/verify.py +python3 -I -O -W error -B research/source-bound-signed-home-add/verify.py +``` + +The complete-field corpus contains16 successes and6 late-overflow rejections, +checked against unbounded integers. It covers widths2–17, signed endpoints, +minimum-source cancellation, nontrivial P/S/r and huge encoded cutoff. +Additional checks distinguish wrong sign and unequal same-length headers. +Two already-reserved fixtures use actual qualified raw-native field/lifetime +IDs for source-owned and owned-owned contacts; the latter parks a declared +productive input. They do not compute full compiler SourceRow/OwnedBank +addresses or infer selected productive width. Generic relabeling leaves the +graph identical. No owned field receives productive credit. + +The contract supplies matching valid geometry, common grid/current complete +frame and live typed fields. Raw zero initialization, actual view/equal-F +production, rank2 owned MOVE28141 and complete lifetime/caller admission +remain open. On admitted matching pairs only true final signed-component +overflow rejects, before any HOME scatter; rejection cleanup/retry is unclaimed. + +#6990/#7268's rounded rational arithmetic and residue work retain their credit; +neither their general operator nor a faster version is claimed. All five +framework assumptions and κ=.00363005817 remain. Source/precision/stock, +all-word generation and analytic recovery are outside scope. Open next work is +the real typed producer or rank2 MOVE, not a generic initializer alone. +Substantial OpenAI Codex assistance; no human/kernel acceptance asserted. diff --git a/research/source-bound-signed-home-add/PREFLIGHT.md b/research/source-bound-signed-home-add/PREFLIGHT.md new file mode 100644 index 0000000000..e7a5eb9974 --- /dev/null +++ b/research/source-bound-signed-home-add/PREFLIGHT.md @@ -0,0 +1,31 @@ +# Scoped budget and novelty gate + +The early verdict communicated before construction was: proceed with a small +typed ±1 service, not a generic-arithmetic novelty or complete-lifetime claim. +The exact five source contacts were already extracted at bank1526. Their +binary packet/header producer and rank2 owned MOVE remain missing inputs. + +Feasible fixed graph: compare/skip Gamma1–4/6 by a unary prefix-length guide; +decode the fifth Gamma width to unary with doubling, in O(E+w), because the +sum of proper binary prefixes is less than w. A component costs a paid w-bit +seek, right-to-left one-carry arithmetic and paid full-width restoration. +Thus the complete bill is O(E+V)=O(F), since w<=V. Three private unary tapes +suffice. SUB is T+~S+1, avoiding intermediate negation overflow on the minimum +source. Only completed signed components decide overflow. B1 still pays +O(KF) delivery and delays all HOME scatter until complete primitive return. + +#6990 at38cd824c60f2bb5c6f2603f848a9487cb3a57965 already proves compact rounded +fixed-rational ADD, cancellation and full lifecycle in a coded Controller ABI. +#7268 at618ff7af4ac85c63ee2c39acc69bf763ed35b60a reduces its signed odd-residue +control. They are credited; this packet ABI does not require their larger +rational numerator/quotient/rounding implementation. No superiority claim. + +GitHub nonempty searches returned30 PRs for Gamma+ADD+literal and3 for +Gamma+signed+addition, with incomplete_results=false. None of the returned +titles supplied this six-positive-Gamma, complete packed B1 two-HOME service. +This is bounded metadata evidence, not a general novelty guarantee. + +The full fresh bodies of #7484/#7485/#7486 were also read on refresh. They +concern later #7481 bank1533 recovery, role235 paid bypass and signed idle +rank obstruction respectively, not this physical arithmetic or selected +bank1526 interface. Canonical main remains e54523517d0f03e58352e647c403a5af3e525a57. diff --git a/research/source-bound-signed-home-add/PROOF.md b/research/source-bound-signed-home-add/PROOF.md new file mode 100644 index 0000000000..737581fc27 --- /dev/null +++ b/research/source-bound-signed-home-add/PROOF.md @@ -0,0 +1,215 @@ +# Exact signed ±1 contacts on complete Gamma/HOME fields + +Scoped literal primitive; Apache-2.0; substantial OpenAI Codex assistance. +Canonical main remains e54523517d0f03e58352e647c403a5af3e525a57. No new κ. + +## 1. Concrete source and supplied field domain + +SOURCE-CONTACTS.json retains the authenticated selected #7000 native bank1526 +lifetime. The exact scalar contacts are SUBs at28041,28129,28135,28139, with +sources1349,728,729,730 and target1526 in chart601; and ADD at28159, source1526 +to target1515 in chart470. Coefficients are exactly -1,-1,-1,-1,+1. +The archive is pinned at172f4535ce8dcff79f626410af845f757c1563be with exact +gzip and canonical word hashes. Optional `--source-repo` re-extracts all five +contacts read-only and compares the complete archive hashes. Default replay +uses the retained compact witness. The source CALLER and format producer are +not executed or admitted by these local contacts. + +Take two physically distinct source/target HOME fields with identical six +positive canonical Gamma headers `(f,r,P,S,w,cutoff)` and exact packed DATA. +Let E be the complete six-code length, V=`2PSr2^(9f)w`, F=E+V, and w>=2. +Every real and imaginary numerator is an arbitrary signed w-bit two's-complement +integer, MSB first. The scientific interpretation requires the same supplied +common grid and actual current frame on both operands. Matching header bits +proves geometry equality, not frame/grid equality; those are typed caller +premises, bound to chart601/470 by the source contacts. The cutoff is opaque +metadata to ADD/SUB; no MOVE integrality or leaf-cutoff condition is needed. + +B1's compatible ABI supplies `^` at relative origin0, outside `|`, heads at +origins and complete common-F bodies. Three private tapes L,W,B are distinct +from both operands and HOME. They have `^` at0, head0 and blank required +positive windows. Earlier history and opaque exteriors remain charged. This +does not construct a valid packet from raw owned zeros. + +**Claim.** Each fixed sign has one uniform finite graph computing target plus +or minus source exactly on every DATA component, preserving all source/header +values, returning all successful working heads/bodies and updating the same +target HOME. On the supplied valid domain it rejects exactly when a completed +signed component is outside the w-bit interval. A rejection before B1 scatter +preserves every HOME; private cleanup/retry on rejection is not claimed. + +The checked B1 graphs have91 states and6 tapes: HOME, two operands and the +three private unary tapes. Graph size, alphabet and instruction set do not +depend on f,r,P,S,w,cutoff or F. Host bit arithmetic constructs a finite +8-case carry truth table offline; no runtime Word or integer oracle is used. + +## 2. Header comparison and physical fifth-code decoding + +Compare both headers while consuming their six Gamma codes in parallel. For +each prefix zero append one unary1 to L. On the first1, move L back; each +erased L digit permits exactly one suffix bit. Reaching L's `^` ends the code +and returns L to its first blank cell. Thus every header bit is inspected and +the first DATA bit is found exactly. Unequal headers reject outside the stated +input domain. No numerical f,r,P,S or cutoff is decoded or treated as free. + +For the fifth code only, initialize unary W to1 at its leading1. On suffix bit +b, replace W=n by2n+b: copy each W digit twice to B, append b if1, erase old W, +copy B back while erasing it, and return both heads. Each move is one cell. +L still controls how many suffix bits remain. This gives exactly the encoded +positive width w and leaves B blank. It never stores w in host control. + +For width suffix prefixes n_i, `sum_i n_i=sum_{j>=1}floor(w/2^j)=1 absorbs the per-component constant. Source/target +full-field head returns cost O(F), and all descriptor clearing is included. +Since w<=V, a deliberately larger standalone bound is + +`T_add <=4096(F+1)`. + +B1's full-field O(RK(F+1)) gather/return remains a separate bill. No memory +lookup, header preparation, per-component reset, source preservation or +transactional staging is free. Both constants are fixed before input sizes +vary. All six encoded fields, including the complete cutoff code, are in E +even when the cutoff value is enormous. This scalar rate needs no fixed f cutoff. + +W and B never exceed w unary digits; L never exceeds E digits. Operand visits +stay within their supplied F-bit bodies and outside delimiters. A generous +historical increment for the primitive is + +`K_final <= K_entry+8(F+2)`. + +K_entry includes all earlier history and opaque storage of the actual owners. +Add B1's separately retained working/home extents. Erasure never subtracts +past visits. Reported monitored head windows are not a reconstructed complete +K_entry. The verifier deliberately retains a larger old private history. + +## 6. Evidence, attribution and remaining obligations + +The literal graphs are executed on22 complete-field cases:16 successful calls +and6 late signed-overflow rejections. Widths2,3,4,5,8,17, nontrivial P/S/r, +signed endpoints/cancellation, and a cutoff value of bitlength2049 (4097 Gamma bits) are covered. +Expected results are ordinary unbounded integer addition/subtraction, separately +encoded after a final range decision. Every successful source/header/result, +head, private body/marker and opaque exterior is checked. Late overflow happens +after private target arithmetic and still has zero HOME writes. Additional +groups distinguish a wrong fixed sign, unequal same-length headers and valid +minimum-source cancellation. Finite tests corroborate the all-w carry/scan +proof; they are not the universal argument. + +Binary addition, two's-complement subtraction, Gamma decoding and unary guides +are classical. #6990 already gives a larger rounded fixed-rational ADD with +cancellation and complete lifecycle in the coded Controller ABI; #7268 reduces +its residue-control graph. The present delta is the exact ±1 scientific +six-Gamma/packed-B1 ABI and the five actual selected contacts, not new generic +arithmetic, a faster version of those packages or arbitrary rational ADD. + +The owned INIT/typed producer, equal-F view transport, rank2 owned MOVE at +28141 and the complete bank lifetime remain open. No full source word, +precision/stock admission, selected supplier, analytic recovery or κ theorem +is claimed. All five framework assumptions remain. + +Open next questions: supply the actual bank1526 formatted-zero producer and +equal-F view proof; or instantiate the different rank2 owned MOVE under the +same field contract. Neither is replaced by a synthetic XOR or an identity. + + +The22 arithmetic/overflow cases use generic two-HOME labels. Two additional +already-reserved fixtures bind qualified raw-native field/lifetime IDs: +source1349 to owned1526 at28041, and owned1526 to owned1515 at28159. +The owned lifetimes are28037–37618 and28153–39073. The owned-owned case +parks an existing productive input HOME; productive_count is1 in each +restricted fixture, never crediting an owned field as a productive output. +That count is test bookkeeping, not the width of the complete selected supplier. +All typed owned packets are supplied live at B1's body entry; no raw-zero +reservation or INIT producer is claimed. Relabeling the same layout with +generic indices leaves the literal graph rules identical. These raw-native +identities are not fabricated full #7423 SourceRow/OwnedBank compiler addresses: +actual source binding and the missing full compiler/producer installation +remain separate. + + +## 7. Current-source all-column scalar convention + +The primary semantic source is the exact selected #7000 application review, +main e54523517d0f03e58352e647c403a5af3e525a57, sections2 and4, retained at +inputs/selected-application-review.md. Git blob: +3dd1af2285e597676725e85ad4f65e7ad326d695; SHA256: +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055. +Section2 places scalar contacts in equal frames and keeps exterior rational +coefficients unchanged at every f. Only the native phase i^a lifts to i^(af); +no tensor power is distributed over ADD or a sum. Section4 implements fixed +reduced a/b with a,b compiled constants. Thus the five -1/+1 tokens mean +literal exterior -1/+1 for every f, not (-1)^f. Indeed linearity gives +U^(tensor f)(y±x)=U^(tensor f)y±U^(tensor f)x. This current selected review, +under its retained assumptions, is the scalar source binding; token equality +alone would not establish that interpretation. + +A literal two-bit component-boundary probe with contextual even f=2 computes +0-1=-1. The wrong tensorized-sign choice would select ADD and compute+1. +The probe supplies the width guide at that subroutine boundary; it is neither +an uncharged width-decoder claim nor a full f=2 packed field execution. The +complete-field corpus separately executes the physical fifth-code decoder. +This does not admit the still-missing actual packet producer or full caller. diff --git a/research/source-bound-signed-home-add/PUBLICATION-MANIFEST.json b/research/source-bound-signed-home-add/PUBLICATION-MANIFEST.json new file mode 100644 index 0000000000..49a181ee98 --- /dev/null +++ b/research/source-bound-signed-home-add/PUBLICATION-MANIFEST.json @@ -0,0 +1,176 @@ +{ + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "claim": "Scoped exact selected +/-1 packed HOME primitive; no new kappa; all framework assumptions remain", + "source_freeze": "Original author freeze/checksums preserved as AUTHOR-*; narrow source Boolean adjective correction recorded separately; scientific code and receipts unchanged.", + "independent_review": "review/ROOT-REVIEW.md", + "files": [ + { + "path": "AUTHOR-CHECKSUMS.sha256", + "bytes": 1360, + "sha256": "9a1753820afd8b373e6f2a91d8ea84d65f3cea8ef3baab1f088b8b9283753723", + "git_blob": "b522dd3b34868d9ea28659c2a4494ff36711498f" + }, + { + "path": "AUTHOR-FREEZE.json", + "bytes": 2269, + "sha256": "3505fbd0eb9aa6a881d2d142d666d8bd62c5152a42d45233f88225ab20f2ef09", + "git_blob": "3506f7e6fd05f3e79c5a56f6d555da52576d9ad0" + }, + { + "path": "CHECKSUMS.sha256", + "bytes": 1360, + "sha256": "16c0481581e76949b33357e26a7ffdc6f8a39ec09828f3489c18f407ca0f35cb", + "git_blob": "4b1e401319826028d1c4d8053e3270f1259161a6" + }, + { + "path": "FREEZE.json", + "bytes": 2580, + "sha256": "ddc3d436dfe5f312debe8dd6d6ffbb64c6cf4d386ae03add01074ae322a6321c", + "git_blob": "a78dda8fe41151a42f2eedae506ef8fce43c9091" + }, + { + "path": "NORMAL.log", + "bytes": 26939, + "sha256": "9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642", + "git_blob": "a92f03544bb03d2329bc845b76adb9d6a9916528" + }, + { + "path": "NOTICE.md", + "bytes": 1957, + "sha256": "8d46ade764824f03c98a4a1319521e946158f9c7aaa4638d94c656133e18b093", + "git_blob": "3f4d72ffe066e478cedb97b7dc8078de6e20966d" + }, + { + "path": "OPTIMIZED.log", + "bytes": 26939, + "sha256": "9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642", + "git_blob": "a92f03544bb03d2329bc845b76adb9d6a9916528" + }, + { + "path": "OVERLAP.json", + "bytes": 2146, + "sha256": "4eff9eff88b502de439e37c0359c8d9a167bb1ddc2ec6c288526b1d117bb06b3", + "git_blob": "520eb125336fc9dda3c282071b85a079e8cb2cc9" + }, + { + "path": "PR-DESCRIPTION.md", + "bytes": 4403, + "sha256": "6085d93ba506bfe2ae3873edbe0460583431c033e24e789fed2f07e02dd4ec78", + "git_blob": "9adf58c68814bb8d1ab27f0e6acf101f2c3d6151" + }, + { + "path": "PR.md", + "bytes": 2843, + "sha256": "1aa665f371a03c081092e6c8ecf0ae520bd0a6c04e8ca14d77e89fc1236b2031", + "git_blob": "ad2f3c42e2487a14c45fd7eac2131358bfad74cc" + }, + { + "path": "PREFLIGHT.md", + "bytes": 1940, + "sha256": "0b6a0c2c3bfa2e12511a56aab10d0d899080991a3223d64fdc36d2b2bf97bbb6", + "git_blob": "e7a5eb9974f7c817af00fd51fc271928cda5bbc6" + }, + { + "path": "PROOF.md", + "bytes": 12543, + "sha256": "84e9184ac4e53816b2c622e467be76eb08d4775bb4004c854c52a604e21061fc", + "git_blob": "737581fc274a63705339eeb53d5b70c212644579" + }, + { + "path": "README.md", + "bytes": 6414, + "sha256": "32883cda59087487ffecc18824cb55bd2528c6e54e7d5dc14c3256ea38937682", + "git_blob": "7fcf26d546050c1753d88a653a0640ec0ad80ae6" + }, + { + "path": "RESULT.json", + "bytes": 26939, + "sha256": "9a08d24d5322a531d78a114ddd36bb92f3766bfc96a244d2a0531f9133fb6642", + "git_blob": "a92f03544bb03d2329bc845b76adb9d6a9916528" + }, + { + "path": "SOURCE-CONTACTS.json", + "bytes": 5173, + "sha256": "c82c95ddc011e6cea480435557e57165c3962b522cdbb3ea41ccaaadb026fa2e", + "git_blob": "8d09b1049a7ea6cfe5ae0096a845da5ef1d175c9" + }, + { + "path": "SOURCES.json", + "bytes": 1643, + "sha256": "7da540e288b8872cdeb7ca476200daafff2257c9ad4aaf582c9aff1ac37ec233", + "git_blob": "bd021f5f8f11a80a808b332e1d542ebba314ae59" + }, + { + "path": "add.py", + "bytes": 5110, + "sha256": "5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b", + "git_blob": "ff9b8c45e37f0f3f5f6043efe6ed74b3fd4a8fe2" + }, + { + "path": "inputs/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da" + }, + { + "path": "inputs/selected-application-review.md", + "bytes": 25533, + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695" + }, + { + "path": "inputs/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7" + }, + { + "path": "review/MOVE-BOOLEAN-CORRECTION.json", + "bytes": 1857, + "sha256": "bd60a3ed06f660b3177b5d0e43ef5e0a7451f66e15bc23132439030d3d0ff9e8", + "git_blob": "fa8f408384f68823c853ef8358b516617806e0e1" + }, + { + "path": "review/PUBLICATION-REMOTE-SOURCES.json", + "bytes": 517, + "sha256": "3e6451986cf2da38ed0aee07449a4df0a4bc679bc45407fd5167ae58d29375f2", + "git_blob": "f095ef759e30f0d7fd3c11862b9e49bfc1d21796" + }, + { + "path": "review/PUBLICATION-REPLAY.json", + "bytes": 619, + "sha256": "c06fddaea1ba5dd475f3d8440098194af464c2df0ed551cb3cdf63c6fe38310d", + "git_blob": "f99a95b11b22ab818ce8068fdd99c3bf5c8d0148" + }, + { + "path": "review/RESULT.json", + "bytes": 4247, + "sha256": "81d9b895f24bcbdae0b5c704977130983a38cb68a5ab56341c55262eb01a5264", + "git_blob": "ee7ed9846765ec10118bad64d7534d0a325deab1" + }, + { + "path": "review/ROOT-REVIEW.md", + "bytes": 3852, + "sha256": "6f1d8e84cfe604c5bb0eab6fb64d1300fb50b0ea2cd07c9e125616548d166660", + "git_blob": "26e0dea10460f2348b42348a950ce1004a2710f2" + }, + { + "path": "review/check_signed_add_root.py", + "bytes": 6608, + "sha256": "482d49719776621535e24419274275d366320d8e43a6d0d35de5b87072f4716c", + "git_blob": "3e0ec3a664b22bce6f7c8234db42b15964d9d2e4" + }, + { + "path": "review/owned-ascent-contract-verify.py", + "bytes": 12434, + "sha256": "748bcd3a4d78002ff065c67872650bf9bfae8f0ab87fef8af2bfda4d4a31d2e6", + "git_blob": "b3683d81a1b4b6f7468cf3cb52f6144375d3377f" + }, + { + "path": "verify.py", + "bytes": 8871, + "sha256": "aa1782a734254305814865a13a6326f3739741af80bb442e760a9047efdfa7de", + "git_blob": "8b41a55e5b38931d8156ce06f1990f204a8ceddf" + } + ] +} diff --git a/research/source-bound-signed-home-add/README.md b/research/source-bound-signed-home-add/README.md new file mode 100644 index 0000000000..7fcf26d546 --- /dev/null +++ b/research/source-bound-signed-home-add/README.md @@ -0,0 +1,116 @@ +# Exact ±1 ADD/SUB on complete Gamma/HOME fields + +Two uniform literal graphs now implement source-bound scientific ±1 contacts +on two valid complete six-Gamma||packed-DATA fields. Each uses91 states and +6 tapes, physically decodes signed width from the fifth Gamma code, preserves +source/header values, and returns the target to the same HOME. The bit carry +is classical; the addition is the complete packed/B1 ABI, paid lifecycle and +actual selected source-contact binding. + +The four SUBs are selected #7000 events28041,28129,28135,28139, target1526, +sources1349/728/729/730 at chart601. Event28159 is ADD1526→1515 at chart470. +The separate rank2 owned MOVE28141 is retained as an open dependency. +SOURCE-CONTACTS.json pins the compact extraction and original archive hashes. + +Standalone cost is at most4096(F+1), with historical increment at most8(F+2). +All header comparison, physical width decoding, source rereads, component +seeks, carries, returns, resets and private retirement are included. B1's +separate O(RKF) full-field delivery remains charged. The graph is independent +of f,r,P,S,w,cutoff and F; even enormous cutoff values pay only encoded bits. + +## Reproduce + +Python3.12 and standard library only, from the repository root: + +```sh +python3 -I -W error -B research/source-bound-signed-home-add/verify.py +python3 -I -O -W error -B research/source-bound-signed-home-add/verify.py +``` + +Expected marker: `PASS_SOURCE_BOUND_SIGNED_HOME_ADD`. `--write` regenerates +RESULT.json. Optional source re-extraction, from an existing repository: + +```sh +python3 -I -W error -B research/source-bound-signed-home-add/verify.py --source-repo /path/to/source/repo +``` + +This authenticates the exact gzip/canonical selected word and all five actual +contacts read-only. Default replay needs no Git, network or shared checkout. + +The22 complete-field cases include16 successes and6 late final-overflow +rejections, widths2/3/4/5/8/17, signed endpoints/cancellation, nontrivial P/S/r, +and a cutoff value of bitlength2049 (4097 Gamma bits). Expected output uses Python integer +addition/subtraction and one final signed-range decision. Every success checks +full source/header/DATA, every head/marker/body and opaque exteriors. Earlier +private history remains retained. Late overflow changes private target data +after gather but leaves both HOME fields unwritten and unchanged. + +Additional checks distinguish wrong sign, unequal same-length headers and the +positive minimum-source cancellation case `(-8)-(-8)=0`. SUB never first +negates the minimum source in the public width. The universal claim rests on +the carry/MSB, Gamma-prefix and complete-scan proof, not finite widths. + +## Supplied contract and limits + +Headers must be identical positive six-code geometries, DATA complete, and +source/target physically distinct with the same supplied grid and actual +current frame. Frame equality is not inferred from header equality. Cutoff is +opaque scalar metadata, not a restriction on this arithmetic. This service +is not a general malformed-volume validator. On valid matching pairs only true +completed signed-component overflow rejects. Private cleanup/retry after +rejection is not claimed. B1 may rewrite source HOME with identical bits. + +Raw zero storage is not a formatted packet. Owned initialization, real view +transport/equal-F production, rank2 MOVE, complete bank lifetime, all-word +source generation, precision/stock and analytic recovery remain open. No new +κ or global assumption discharge is asserted; all five assumptions remain. + +## Open next questions + +1. Supply the actual typed-zero producer and equal-F transport for bank1526; + the actual source opportunity is documented in the retained format gate. +2. Install the different rank2 owned MOVE28141 under a proved field ABI. +3. Extend coefficient scope only with its full rounding/division/cancellation + and lifecycle bill; this package does not replace #6990/#7268's rational work. + +Prepared with substantial OpenAI Codex assistance. See PROOF.md, NOTICE.md +and PREFLIGHT.md. No independent human or formal-kernel acceptance is claimed. + + +The22 arithmetic/overflow cases use generic two-HOME labels. Two additional +already-reserved fixtures bind qualified raw-native field/lifetime IDs: +source1349 to owned1526 at28041, and owned1526 to owned1515 at28159. +The owned lifetimes are28037–37618 and28153–39073. The owned-owned case +parks an existing productive input HOME; productive_count is1 in each +restricted fixture, never crediting an owned field as a productive output. +That count is test bookkeeping, not the width of the complete selected supplier. +All typed owned packets are supplied live at B1's body entry; no raw-zero +reservation or INIT producer is claimed. Relabeling the same layout with +generic indices leaves the literal graph rules identical. These raw-native +identities are not fabricated full #7423 SourceRow/OwnedBank compiler addresses: +actual source binding and the missing full compiler/producer installation +remain separate. + + +## Current-source all-column scalar convention + +The primary semantic source is the exact selected #7000 application review, +main e54523517d0f03e58352e647c403a5af3e525a57, sections2 and4, retained at +inputs/selected-application-review.md. Git blob: +3dd1af2285e597676725e85ad4f65e7ad326d695; SHA256: +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055. +Section2 places scalar contacts in equal frames and keeps exterior rational +coefficients unchanged at every f. Only the native phase i^a lifts to i^(af); +no tensor power is distributed over ADD or a sum. Section4 implements fixed +reduced a/b with a,b compiled constants. Thus the five -1/+1 tokens mean +literal exterior -1/+1 for every f, not (-1)^f. Indeed linearity gives +U^(tensor f)(y±x)=U^(tensor f)y±U^(tensor f)x. This current selected review, +under its retained assumptions, is the scalar source binding; token equality +alone would not establish that interpretation. + +A literal two-bit component-boundary probe with contextual even f=2 computes +0-1=-1. The wrong tensorized-sign choice would select ADD and compute+1. +The probe supplies the width guide at that subroutine boundary; it is neither +an uncharged width-decoder claim nor a full f=2 packed field execution. The +complete-field corpus separately executes the physical fifth-code decoder. +This does not admit the still-missing actual packet producer or full caller. diff --git a/research/source-bound-signed-home-add/RESULT.json b/research/source-bound-signed-home-add/RESULT.json new file mode 100644 index 0000000000..a92f03544b --- /dev/null +++ b/research/source-bound-signed-home-add/RESULT.json @@ -0,0 +1,1708 @@ +{ + "cases": [ + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "365c7dd4cc5d0f9f362eef2ae23b44e09565e89e46dbaee85dce71fdbcdaaf80", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "e57302c0c7eee8b47d9e9bc4db53cb2cc74c0a5b0261d8db83da6830558243c0", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "907f235c1acce7e3079f86e53d4bd62677e88ab07127b18f1cbbe85dcc4d61be", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "beeba5fe1b60599d66b99389aa014fad4e04fba4525baf2dfbedb7bfb89c9aff", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "fc5bc6d7101dfd498724c0b58ea0066b176544d6c0079caed388bf03d48201aa", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "d305f1e9575f350f0e47fe12cfc9b3e92d52b0dee2232a673b4780a9c946d02f", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "ADD", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "b9231be7c5817dc1ebd031ceeb72b36ea830fe55c57ed0a5e36a329a9abd11b8", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "65d67b81b1df9c650e803bd8ae9381e927a0b7bf97907a438657a4b03e850045", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b419d3755e65b8462ca58b8284c0ef4d9bdf49ec6f7fe0cb60edff71259253a4", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "ADD", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "657bd69aeefdbb3caa5f3de6b50e7b9809d832b3f07ee5c0511e2600256faa87", + "states": 91, + "steps": 98515 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 4112, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "11900dc46f6db133c998d1e5278f790351e71affa1f00f9232528303cba0fc2e", + "states": 91, + "steps": 47301 + }, + { + "E": 8, + "F": 3080, + "HOME_writes": 6160, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 9262 + ] + ], + "final_head_spans": [ + [ + 17, + 6180 + ], + [ + 18, + 3099 + ], + [ + 19, + 3100 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 9262 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 3, + 1 + ], + "source_sha256": "9f655ce3e89f74172729e1274cf611dae04c2c7d770975b6f1cbb107f32a375b", + "states": 91, + "steps": 66763 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 8212, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "b80f883a61b69e38bf7203d92d044b5e5a169c2d56bb8227d1c50608942481a2", + "states": 91, + "steps": 86286 + }, + { + "E": 10, + "F": 5130, + "HOME_writes": 10260, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 15412 + ] + ], + "final_head_spans": [ + [ + 17, + 10280 + ], + [ + 18, + 5149 + ], + [ + 19, + 5150 + ], + [ + 20, + 23 + ], + [ + 21, + 27 + ], + [ + 22, + 15412 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 5, + 1 + ], + "source_sha256": "f858911735946c9f1855cd3015b4f8c831f8bd924815e7cfb8e2d2b636877567", + "states": 91, + "steps": 105748 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 16408, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "2679b556160ff6a79bfe7514dd337e22ab64dde5c1f25072892145921dc91649", + "states": 91, + "steps": 164209 + }, + { + "E": 14, + "F": 17422, + "HOME_writes": 34844, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 52288 + ] + ], + "final_head_spans": [ + [ + 17, + 34864 + ], + [ + 18, + 17441 + ], + [ + 19, + 17442 + ], + [ + 20, + 25 + ], + [ + 21, + 39 + ], + [ + 22, + 52288 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 1 + ], + "source_sha256": "3929e8c193d7c0eb3374324e0adc9ebd6fb9cc6b65a12d8523159626d183b2b2", + "states": 91, + "steps": 339470 + }, + { + "E": 14, + "F": 36878, + "HOME_writes": 73756, + "components": 12288, + "entry_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 110656 + ] + ], + "final_head_spans": [ + [ + 17, + 73776 + ], + [ + 18, + 36897 + ], + [ + 19, + 36898 + ], + [ + 20, + 22 + ], + [ + 21, + 25 + ], + [ + 22, + 110656 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "source_sha256": "63f7ba969bdff4a407b94d7d31cb8f2cdfa38d946700cbaa34991182662995d6", + "states": 91, + "steps": 799019 + }, + { + "E": 4106, + "F": 8202, + "HOME_writes": 16404, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24628 + ] + ], + "final_head_spans": [ + [ + 17, + 16424 + ], + [ + 18, + 8221 + ], + [ + 19, + 8222 + ], + [ + 20, + 2069 + ], + [ + 21, + 26 + ], + [ + 22, + 24628 + ] + ], + "operation": "SUB", + "overflow": false, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "source_sha256": "ebae0a4e69c14d6c617410cf264229314bdc6c134c59682608cd3e74e4102adc", + "states": 91, + "steps": 151822 + }, + { + "E": 8, + "F": 2056, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 6190 + ] + ], + "final_head_spans": [ + [ + 17, + 4132 + ], + [ + 18, + 2075 + ], + [ + 19, + 2076 + ], + [ + 20, + 22 + ], + [ + 21, + 24 + ], + [ + 22, + 6190 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "source_sha256": "c952f9a76fd5d866a47d5208152c12a3ed0aedfea92b0bcb66c45eb1fe461e8f", + "states": 91, + "steps": 30815 + }, + { + "E": 10, + "F": 4106, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 12340 + ] + ], + "final_head_spans": [ + [ + 17, + 8232 + ], + [ + 18, + 4125 + ], + [ + 19, + 4126 + ], + [ + 20, + 23 + ], + [ + 21, + 26 + ], + [ + 22, + 12340 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 4, + 1 + ], + "source_sha256": "f0d8f2272df041fae5b9f8a9db1c9e416136442a3f04be73fc5cfc03f072367b", + "states": 91, + "steps": 53392 + }, + { + "E": 12, + "F": 8204, + "HOME_writes": 0, + "components": 1024, + "entry_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 18 + ], + [ + 19, + 19 + ], + [ + 20, + 20 + ], + [ + 21, + 21 + ], + [ + 22, + 24634 + ] + ], + "final_head_spans": [ + [ + 17, + 16428 + ], + [ + 18, + 8223 + ], + [ + 19, + 8224 + ], + [ + 20, + 24 + ], + [ + 21, + 30 + ], + [ + 22, + 24634 + ] + ], + "operation": "SUB", + "overflow": true, + "shape": [ + 1, + 1, + 1, + 1, + 8, + 1 + ], + "source_sha256": "4d7d343e5207eb69dccf3bfb9b52592f7cea781a724f66d99ec1db577c29ec5c", + "states": 91, + "steps": 98515 + } + ], + "contacts": [ + [ + 28041, + [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + ], + [ + 28129, + [ + "ADD", + 1526, + 728, + "-1", + 601 + ] + ], + [ + 28135, + [ + "ADD", + 1526, + 729, + "-1", + 601 + ] + ], + [ + 28139, + [ + "ADD", + 1526, + 730, + "-1", + 601 + ] + ], + [ + 28159, + [ + "ADD", + 1515, + 1526, + "1", + 470 + ] + ] + ], + "controls": [ + "wrong_fixed_coefficient_sign", + "mismatched_equal_length_headers", + "minimum_source_subtraction_cancellation", + "even_f_exterior_minus_one_not_tensor_phase_component_boundary" + ], + "history_boundary": "K_entry includes opaque exterior storage and earlier history; monitored windows do not infer it.", + "marker": "PASS_SOURCE_BOUND_SIGNED_HOME_ADD", + "native_identity_fixtures": [ + { + "K": 2, + "body_entry": "already_reserved_and_typed", + "event_index": 28041, + "operand_indices": [ + 0, + 1 + ], + "operation": "SUB", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 1349 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 86286, + "tag_relabel_graph_identical": true + }, + { + "K": 3, + "body_entry": "already_reserved_and_typed", + "event_index": 28159, + "operand_indices": [ + 1, + 2 + ], + "operation": "ADD", + "owners": [ + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-productive-input", + 0 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1526, + 28037, + 37618 + ], + [ + [ + "selected-7000-raw-native", + "local-occurrence-0" + ], + "native-owned-lifetime", + 1515, + 28153, + 39073 + ] + ], + "productive_count": 1, + "scope": "qualified raw-native identity; full #7423 compiler addresses are not generated", + "steps": 102714, + "tag_relabel_graph_identical": true + } + ], + "scope": "fixed \u00b11 source contacts, same valid \u03936 headers/common grid; producer, rank2 MOVE and complete lifetime remain outside scope", + "tapes": 6 +} diff --git a/research/source-bound-signed-home-add/SOURCE-CONTACTS.json b/research/source-bound-signed-home-add/SOURCE-CONTACTS.json new file mode 100644 index 0000000000..8d09b1049a --- /dev/null +++ b/research/source-bound-signed-home-add/SOURCE-CONTACTS.json @@ -0,0 +1,333 @@ +{ + "source": { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/reference/selected-native.json.gz", + "bytes": 350722, + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "blob": "74563a7867d9d762b6588f65362369668841bb3e", + "derived_local": "reference/SOURCE-FRAMES.json", + "extraction": "event 24472; complete frames named by event[2:4]; canonical JSON word hash is recorded in RECIPE.json; source archive is not vendored" + }, + "owner": 1526, + "start": 28037, + "end": 37618, + "events": [ + { + "index": 28037, + "event": [ + "INIT", + 1526, + 601 + ] + }, + { + "index": 28041, + "event": [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + }, + { + "index": 28129, + "event": [ + "ADD", + 1526, + 728, + "-1", + 601 + ] + }, + { + "index": 28135, + "event": [ + "ADD", + 1526, + 729, + "-1", + 601 + ] + }, + { + "index": 28139, + "event": [ + "ADD", + 1526, + 730, + "-1", + 601 + ] + }, + { + "index": 28141, + "event": [ + "MOVE", + 1526, + 601, + 470, + true + ] + }, + { + "index": 28159, + "event": [ + "ADD", + 1515, + 1526, + "1", + 470 + ] + }, + { + "index": 37618, + "event": [ + "CLEAR", + 1526, + 470 + ] + } + ], + "frames": { + "470": [ + 75, + 137, + 265 + ], + "601": [ + 137 + ] + }, + "program_length": 71261, + "canonical_word_sha256": "91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097", + "context": [ + { + "index": 28032, + "event": [ + "ADD", + 1097, + 1088, + "1/2", + 3 + ] + }, + { + "index": 28033, + "event": [ + "ADD", + 14, + 786, + "-1", + 3 + ] + }, + { + "index": 28034, + "event": [ + "SCALE", + 449, + "-1", + 3 + ] + }, + { + "index": 28035, + "event": [ + "ADD", + 786, + 1349, + "-1/4", + 3 + ] + }, + { + "index": 28036, + "event": [ + "ADD", + 168, + 212, + "1", + 3 + ] + }, + { + "index": 28037, + "event": [ + "INIT", + 1526, + 601 + ] + }, + { + "index": 28038, + "event": [ + "ADD", + 212, + 449, + "1/2", + 3 + ] + }, + { + "index": 28039, + "event": [ + "MOVE", + 1349, + 3, + 601, + false + ] + }, + { + "index": 28040, + "event": [ + "ADD", + 124, + 212, + "1", + 3 + ] + }, + { + "index": 28041, + "event": [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + }, + { + "index": 28042, + "event": [ + "ADD", + 1126, + 1128, + "1/2", + 3 + ] + }, + { + "index": 28043, + "event": [ + "ADD", + 1128, + 1281, + "2", + 3 + ] + } + ], + "move_rank": 2, + "frame_chart_is_not_geometry": "Both are nine-coordinate charts; the frame list lengths 1 and 3 do not change the nine-coordinate ambient or by themselves change f.", + "available_donor_frames": [ + { + "owner": 728, + "initial_frame": 3, + "last_MOVE_before_INIT": { + "index": 27439, + "event": [ + "MOVE", + 728, + 3, + 601, + false + ] + } + }, + { + "owner": 729, + "initial_frame": 3, + "last_MOVE_before_INIT": { + "index": 25888, + "event": [ + "MOVE", + 729, + 3, + 601, + false + ] + } + }, + { + "owner": 730, + "initial_frame": 3, + "last_MOVE_before_INIT": { + "index": 27441, + "event": [ + "MOVE", + 730, + 3, + 601, + false + ] + } + }, + { + "owner": 1349, + "initial_frame": 3, + "last_MOVE_before_INIT": null + } + ], + "same_volume_header_counterexample": [ + { + "shape": [ + 1, + 1, + 1, + 36, + 4, + 1 + ], + "E": 20, + "V": 147456, + "F": 147476 + }, + { + "shape": [ + 1, + 1, + 6, + 6, + 4, + 1 + ], + "E": 18, + "V": 147456, + "F": 147474 + } + ], + "contact_owned_lifetimes": { + "1526": { + "init_index": 28037, + "init": [ + "INIT", + 1526, + 601 + ], + "clear_index": 37618, + "clear": [ + "CLEAR", + 1526, + 470 + ] + }, + "1515": { + "init_index": 28153, + "init": [ + "INIT", + 1515, + 470 + ], + "clear_index": 39073, + "clear": [ + "CLEAR", + 1515, + 470 + ] + } + } +} diff --git a/research/source-bound-signed-home-add/SOURCES.json b/research/source-bound-signed-home-add/SOURCES.json new file mode 100644 index 0000000000..bd021f5f8f --- /dev/null +++ b/research/source-bound-signed-home-add/SOURCES.json @@ -0,0 +1,36 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "local": "inputs/tape_graph.py", + "bytes": 12069, + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/tape_graph.py" + }, + { + "local": "inputs/machine.py", + "bytes": 6041, + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "origin": "Retained verifier utility from preceding MOVE/HOME frozen manifest efda264fee073edc344a0d516760be28ca8dea6988d64304d846864a9d82678f; not a numerical theorem premise." + }, + { + "local": "SOURCE-CONTACTS.json", + "bytes": 5173, + "sha256": "c82c95ddc011e6cea480435557e57165c3962b522cdbb3ea41ccaaadb026fa2e", + "git_blob": "8d09b1049a7ea6cfe5ae0096a845da5ef1d175c9", + "origin": "Compact exact selected archive extraction; original gzip/canonical pins inside, optional --source-repo." + }, + { + "local": "inputs/selected-application-review.md", + "bytes": 25533, + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "role": "primary current-source scalar all-column convention, sections2 and4" + } + ] +} diff --git a/research/source-bound-signed-home-add/add.py b/research/source-bound-signed-home-add/add.py new file mode 100644 index 0000000000..ff9b8c45e3 --- /dev/null +++ b/research/source-bound-signed-home-add/add.py @@ -0,0 +1,98 @@ +"""Uniform packed Γ6 signed ±1 ADD/SUB; classical carry, new paid ABI. +Apache-2.0. Prepared with OpenAI Codex assistance. No runtime Word oracle. +""" +from pathlib import Path +import importlib.util,sys,hashlib +HERE=Path(__file__).resolve().parent +sys.dont_write_bytecode=True;sys.pycache_prefix=str(HERE/'_unwritten_cache') +if Path(sys.pycache_prefix).exists():raise ValueError('bytecode isolation path exists') +def load(name,path): + s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);sys.modules[name]=m;s.loader.exec_module(m);return m +if hashlib.sha256((HERE/'inputs/tape_graph.py').read_bytes()).hexdigest()!='7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54':raise ValueError('B1 source drift') +if hashlib.sha256((HERE/'inputs/machine.py').read_bytes()).hexdigest()!='ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee':raise ValueError('literal interpreter source drift') +D=load('signed_add_dispatch',HERE/'inputs/tape_graph.py') +S,T,L,W,B=1,2,3,4,5 +TAPES=6 + +def origin_one(g,t,after):return g.rewind(t,g.jump(after,((t,1),))) + +def double_plus(g,bit,after): + """W=n unary, B blank; return W=2n+bit, B blank, both at cell1.""" + finish=origin_one(g,W,origin_one(g,B,after)) + transfer=g.state('width-transfer') + g.add(transfer,finish,tests=((B,'_'),)) + g.add(transfer,transfer,tests=((B,'1'),),writes=((B,'_'),(W,'1')),moves=((B,1),(W,1))) + begin_transfer=origin_one(g,B,g.jump(transfer,((W,1),))) + erase_old=g.rewind(W,begin_transfer,erase=True) + append=g.jump(erase_old) if not bit else g.state('width-append') + if bit:g.add(append,erase_old,writes=((B,'1'),),moves=((B,1),)) + loop=g.state('width-double');second=g.state('width-double-second') + g.add(loop,append,tests=((W,'_'),)) + g.add(loop,second,tests=((W,'1'),),writes=((B,'1'),),moves=((B,1),)) + g.add(second,loop,writes=((B,'1'),),moves=((B,1),(W,1))) + return loop + +def forward_width(g,after): + loop=g.state('width-forward') + g.add(loop,after,tests=((W,'_'),)) + g.add(loop,loop,tests=((W,'1'),),moves=((W,1),(S,1),(T,1))) + return loop + +def primitive(g,name,arity,after,stages=None): + if name not in ('ADD','SUB') or arity!=2:raise ValueError('fixed ±1 two-operand service') + stages={} if stages is None else stages;sub=name=='SUB' + # Successful private cleanup; source and target working copies are returned. + done=g.rewind(S,g.rewind(T,g.rewind(L,g.rewind(B,after)))) + clear=g.state('retire-width') + g.add(clear,g.rewind(W,done),tests=((W,'_'),)) + g.add(clear,clear,tests=((W,'1'),),writes=((W,'_'),),moves=((W,1),)) + cleanup=clear + next_component=g.state('next-component');reject=g.state('true-overflow');g.rules[reject]=[] + stages['overflow']=reject;stages['component_entry']=next_component + # After arithmetic, heads are one cell left of this component; restore its + # full width before considering the next component. All moves are paid. + next_ready=origin_one(g,W,next_component) + restore=forward_width(g,next_ready) + restore=g.jump(restore,((S,1),(T,1),(W,1))) + loops={c:g.state('carry-'+str(c)) for c in (0,1)} + checks={(c,o):g.state('MSB-check') for c in (0,1) for o in (0,1)} + for (c,overflow),state in checks.items(): + g.add(state,loops[c],tests=((W,'1'),)) + g.add(state,reject if overflow else restore,tests=((W,'^'),)) + for carry,state in loops.items(): + for s in (0,1): + for t in (0,1): + total=t+(1-s if sub else s)+carry;out=total%2;c=total//2 + overflow=int((t!=s if sub else t==s) and out!=t) + g.add(state,checks[c,overflow],tests=((S,str(s)),(T,str(t))),writes=((T,str(out)),),moves=((S,-1),(T,-1),(W,-1))) + lsb=g.jump(loops[1 if sub else 0],((S,-1),(T,-1),(W,-1))) + seek=forward_width(g,lsb) + g.add(next_component,cleanup,tests=((S,'|'),(T,'|'))) + for s in '01': + for t in '01':g.add(next_component,seek,tests=((S,s),(T,t))) + # Parse/compare all six positive Γ headers. Only fifth value is decoded. + nxt=next_component + for field in range(5,-1,-1): + prefix=g.state('Gamma-prefix');pop=g.state('Gamma-pop');suffix=g.state('Gamma-suffix') + g.add(prefix,prefix,tests=((S,'0'),(T,'0')),writes=((L,'1'),),moves=((S,1),(T,1),(L,1))) + writes=((W,'1'),) if field==4 else () + g.add(prefix,pop,tests=((S,'1'),(T,'1')),writes=writes,moves=((S,1),(T,1),(L,-1))) + g.add(pop,nxt,tests=((L,'^'),),moves=((L,1),)) + g.add(pop,suffix,tests=((L,'1'),),writes=((L,'_'),),moves=((L,-1),)) + for bit in (0,1): + resume=g.jump(pop,((S,1),(T,1))) + destination=double_plus(g,bit,resume) if field==4 else resume + g.add(suffix,destination,tests=((S,str(bit)),(T,str(bit)))) + nxt=prefix + entry=g.jump(nxt,tuple((t,1) for t in (S,T,L,W,B))) + stages['entry']=entry;stages['return']=after + return entry + +def compile_home(operation,owners=(0,1),operand_indices=(0,1),productive_count=None): + from collections import namedtuple + Event=namedtuple('Event','service owners');stages={} + if productive_count is None:productive_count=len(owners) + active=tuple(owners[i] for i in operand_indices) + g=D.compile_graph((Event(operation,active),),owners,productive_count=productive_count, + primitive=lambda g,n,a,k:primitive(g,n,a,k,stages)) + return g,stages diff --git a/research/source-bound-signed-home-add/inputs/machine.py b/research/source-bound-signed-home-add/inputs/machine.py new file mode 100644 index 0000000000..fcd4ac01f0 --- /dev/null +++ b/research/source-bound-signed-home-add/inputs/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] gS` with fixed +rational S. It does not exclude q-dependent cover entries, discard nonunit +pivots without charging the bad classes, or permit weights depending on a +child's fresh cover/roles. External weights may depend on exposed ancestors. + +Use the repaired power 768, cutoff 15, floor 16, logarithm power 617, +`H_B=296630000000000`, and the two separate 10^-10 losses. The covered +saving is .0038525298. Freeze two ordinary backends in order: + +``` +.0034 -> .0038507 -> .00385248. +``` + +The first backend is the selected completed .0034 interface, including its +spectators, restored stock and radix boundary. Each subsequent algorithm +uses only its completed predecessor for ordinary maps/high-part exchanges, +with atom exponent ρ=1/250. Its source-bound cost is +`O(C V [e^(1-ρ) + e^((1-ρ)(1-covered)+ρ(1-previous)) + e^ρ log e])`. +The exact positive bootstrap gaps were checked previously. C is the new +finite constant, not one. Freeze each backend's threshold before using it +in the next step; smaller widths use the predecessor. This dependency is +acyclic and supplies the weaker .00376669 used by the complex outer ledger. + +Reserve the full input-dependent row stock with +`D_stock(e)=2+ceil(log_(N_B)(max(1,ceil(e/ceil(e^ρ)))))` and +`W(w)^D_stock(e) S_old`, as in the pinned delayed-cover proof. The high-digit +reserve is `O_fixed(w log e)`. Internal BIT recursion preserves the entire +external complex factor and restores its own borrowed stock. The fixed two +backend levels are not substituted for the input-dependent recursion depth. + +## 4. Exact fixed-rational scalar service + +Choose the per-native-call scale-1125 route, not the independently rounded +ADD implementation. Multiply each actual public entrance by S=1125, execute +the literal word, and divide each completed output by S. All 53,280 boundary +conversions are counted. The previously checked row and pre-product invariant +proves odd divisibility on the common grid described below. + +For a fixed reduced scalar a/b, multiply an unsigned magnitude bit stream +least-significant-bit first. Its state is carry c, and the transition on bit +u emits `(c+|a|u) mod2` and retains `floor((c+|a|u)/2)`. The carry remains +between 0 and |a|; append `bitlength(|a|)+1` zero bits. Reverse direction +for division by fixed positive b. From remainder r and bit u, form `2r+u`, +emit its comparison with b, and keep the remainder after subtracting b when +necessary. Here `0<=r=1, +integer logarithmic degree d0 and positive rational slack δ in the retained +outer bounds, choose an integer j beyond `4d0/δ` with +`C(j+1)^d0 <= 2^(δj)` and freeze the input threshold at least 2^j. Subsequent +ratios decrease, so the inequality holds thereafter. Choose j on a multiple +of δ's denominator to make this an integer comparison. Likewise the retained +record fiber `2^(Omega(p^(1-epsilon)))` eventually exceeds every new fixed +descriptor polynomial; choose the cutoff after its constants/degrees. +Take the maximum of these finitely many cutoffs, the scalar-fit boundary, +stock conditions and the primitive-family cutoffs. No input-dependent +algorithm or growing tape alphabet is introduced by this choice. + +## 7. Compiler funding and outer conclusion + +The independently checked complex invoice has tested price +`C=.00363005817007=κ+7g`, `g=10^-14`. Use product power 1920, cutoff 11, +completion floor 12, offset 1/7 and actual ambient `153^1920`. +The certified bounds give `alpha<1-10^-27`, `gamma,delta<31/32` and +`1/(1+1920·10^-27)+4(31/32)^1920<1`. The separated paid ceiling is below +the target floor. Whole-job completion and integer splitting retain all +their arrays, paid positions and fresh adapters. + +The ambient-cap proof supplies the source band `(N/A,N]` with A=153^1920; +no target of rank A is needed. Logarithm power 2228 and +`H_C=14174600000000000000` give the checked uniform saving `κ+6g`. +All 54 strict and four functional outer predicates pass; their minimum +positive margin is 10^-15. The completed BIT saving .00385248 supplies the +weaker .00376669 premise with ample positive margin. Section 6 changes finite +constants and eventual thresholds, leaving these rank and exponent inequalities +unchanged. The resulting conclusion is the conditional bound + +`T(n)=O(n (log n)^(1-.00363005817))`. + +The five assumptions are still native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. Local owned ascent, global LAMBDA, +mixed/shared native calls and exact odd division have explicit applications +within those assumptions above. The conclusion does not admit arbitrary +rounded providers, the old numerical tape-cost cap, or newer words with the +same headline/interface names. Any changed source needs its affected checks. + +## Attribution and open next questions + +CubeJerry supplied #7000/#7001 and the precision, owned-ascent, global-LAMBDA +and compiler-application work. DreamingOfClouds supplied the shared native, +two-chain and helper constructions; Ali Romman supplied the helper-basis +lineage. Retain zxv's rational BIT/native/compiler work, Jacob Alan Sussman's +mixed integer compiler, icekylinx/Dugongue's frame theory, Cinna Davis, +Matarener, Chris R/Clear1nsight and all unchanged NOTICE attributions. +The phase-polynomial route method and common-grid induction are credited +reuses; the current occurrence map, complete catalogue closure, exact-scalar +application and finite-cost/root-boundary substitutions are this review's work. +Prepared for Douglas Colkitt with substantial OpenAI Codex assistance, +Apache-2.0; no separate human or formal-kernel verification. + +Open next questions: implement the complete fixed-tape dispatcher rather than +its conditional grammar; tighten the deliberately loose scalar/route constants; +and transfer this application to later changed words using exact-source deltas. +Those questions do not turn an archived successor into an admitted result. diff --git a/research/source-bound-signed-home-add/inputs/tape_graph.py b/research/source-bound-signed-home-add/inputs/tape_graph.py new file mode 100644 index 0000000000..f307133f2b --- /dev/null +++ b/research/source-bound-signed-home-add/inputs/tape_graph.py @@ -0,0 +1,281 @@ +"""Literal fixed-tape scan graphs; no indexed payload access in execution. + +Alphabet is fixed. K, all homes and all service choices are frozen in states. +F is never stored in a runtime counter. New material: Apache-2.0. +""" +from dataclasses import dataclass + +ALPHABET = '_01^|$' + + +class Tape: + def __init__(self, text='^'): + self.cells = list(text) + self.head = 0 + self.peak = len(self.cells) + self.visited = {0} + + def read(self): + self.visited.add(self.head) + self.peak = max(self.peak,self.head+1) + return self.cells[self.head] if self.head < len(self.cells) else '_' + + def write(self, value): + self.visited.add(self.head) + if self.head >= 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/source-bound-signed-home-add/review/MOVE-BOOLEAN-CORRECTION.json b/research/source-bound-signed-home-add/review/MOVE-BOOLEAN-CORRECTION.json new file mode 100644 index 0000000000..fa8f408384 --- /dev/null +++ b/research/source-bound-signed-home-add/review/MOVE-BOOLEAN-CORRECTION.json @@ -0,0 +1,40 @@ +{ + "reason": "Final raw MOVE Boolean records owned/private status, not inversion. Correct only the adjective on the still-missing MOVE28141 dependency; exact scalar contacts, arithmetic graph and tests unchanged.", + "previous_remote_commit": "dda488a7df71fdc8939d73f60ea4e700cf9b5612", + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "source": { + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/owned-ascent-contract/verify.py", + "git_blob": "b3683d81a1b4b6f7468cf3cb52f6144375d3377f", + "sha256": "748bcd3a4d78002ff065c67872650bf9bfae8f0ab87fef8af2bfda4d4a31d2e6", + "local": "review/owned-ascent-contract-verify.py" + }, + "changes": [ + { + "path": "PREFLIGHT.md", + "before_sha256": "10928c3c59885cb61173aefc6bf262c61fa74288ea7b65f9ac328f0988a89881", + "after_sha256": "0b6a0c2c3bfa2e12511a56aab10d0d899080991a3223d64fdc36d2b2bf97bbb6" + }, + { + "path": "PROOF.md", + "before_sha256": "08c8b9015a32a164ff09686dd044fb8d940d1a902bf6c21f9bceb2609051d7d9", + "after_sha256": "84e9184ac4e53816b2c622e467be76eb08d4775bb4004c854c52a604e21061fc" + }, + { + "path": "README.md", + "before_sha256": "ece3f40bb226516492d0b2b26790d50c84392d5ac42fb673171035287031fe24", + "after_sha256": "32883cda59087487ffecc18824cb55bd2528c6e54e7d5dc14c3256ea38937682" + }, + { + "path": "PR.md", + "before_sha256": "43883dbcedfd02a857fedb9bfca446337ce5e089cf61ef8f3d67db445b93e775", + "after_sha256": "1aa665f371a03c081092e6c8ecf0ae520bd0a6c04e8ca14d77e89fc1236b2031" + }, + { + "path": "PR-DESCRIPTION.md", + "before_sha256": "b7f6d6a4c8da18da85bfc5f93938641a3846a9651589cf99ea3a23c5c668efe6", + "after_sha256": "6085d93ba506bfe2ae3873edbe0460583431c033e24e789fed2f07e02dd4ec78" + } + ] +} diff --git a/research/source-bound-signed-home-add/review/PUBLICATION-REMOTE-SOURCES.json b/research/source-bound-signed-home-add/review/PUBLICATION-REMOTE-SOURCES.json new file mode 100644 index 0000000000..f095ef759e --- /dev/null +++ b/research/source-bound-signed-home-add/review/PUBLICATION-REMOTE-SOURCES.json @@ -0,0 +1,13 @@ +{ + "verified_remote_exact_bytes": [ + { + "local": "inputs/machine.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "13c29e2df66ba46402d4da5f1d2489ebf333e5fe", + "path": "research/source-bound-move-home-primitive/machine.py", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + } + ], + "other_two_sources": "SOURCES.json pins independently fetched and byte-matched at publication" +} diff --git a/research/source-bound-signed-home-add/review/PUBLICATION-REPLAY.json b/research/source-bound-signed-home-add/review/PUBLICATION-REPLAY.json new file mode 100644 index 0000000000..f99a95b11b --- /dev/null +++ b/research/source-bound-signed-home-add/review/PUBLICATION-REPLAY.json @@ -0,0 +1,26 @@ +{ + "canonical_base": "e54523517d0f03e58352e647c403a5af3e525a57", + "checks": [ + { + "label": "author", + "exit_code": 0, + "receipt_matches": true, + "marker": "PASS_SOURCE_BOUND_SIGNED_HOME_ADD" + }, + { + "label": "optimized", + "exit_code": 0, + "receipt_matches": true, + "marker": "PASS_SOURCE_BOUND_SIGNED_HOME_ADD" + }, + { + "label": "independent", + "exit_code": 0, + "receipt_matches": true, + "marker": "PASS_ROOT_SIGNED_HOME_ADD_REVIEW" + } + ], + "original_manifest_verified": true, + "retained_files": 17, + "full_archive_reextracted": true +} diff --git a/research/source-bound-signed-home-add/review/RESULT.json b/research/source-bound-signed-home-add/review/RESULT.json new file mode 100644 index 0000000000..ee7ed98467 --- /dev/null +++ b/research/source-bound-signed-home-add/review/RESULT.json @@ -0,0 +1,190 @@ +{ + "marker": "PASS_ROOT_SIGNED_HOME_ADD_REVIEW", + "unit_components": [ + { + "operation": "ADD", + "w": 2, + "all_signed_pairs": 16, + "overflow_pairs": 4 + }, + { + "operation": "ADD", + "w": 3, + "all_signed_pairs": 64, + "overflow_pairs": 16 + }, + { + "operation": "ADD", + "w": 4, + "all_signed_pairs": 256, + "overflow_pairs": 64 + }, + { + "operation": "ADD", + "w": 5, + "all_signed_pairs": 1024, + "overflow_pairs": 256 + }, + { + "operation": "ADD", + "w": 6, + "all_signed_pairs": 4096, + "overflow_pairs": 1024 + }, + { + "operation": "SUB", + "w": 2, + "all_signed_pairs": 16, + "overflow_pairs": 4 + }, + { + "operation": "SUB", + "w": 3, + "all_signed_pairs": 64, + "overflow_pairs": 16 + }, + { + "operation": "SUB", + "w": 4, + "all_signed_pairs": 256, + "overflow_pairs": 64 + }, + { + "operation": "SUB", + "w": 5, + "all_signed_pairs": 1024, + "overflow_pairs": 256 + }, + { + "operation": "SUB", + "w": 6, + "all_signed_pairs": 4096, + "overflow_pairs": 1024 + } + ], + "complete_fields": [ + { + "operation": "ADD", + "shape": [ + 1, + 4, + 1, + 1, + 6, + 1 + ], + "F": 24590, + "components": 4096, + "late_overflow": false, + "steps": 500065, + "HOME_writes": 49180, + "early_HOME_writes": 0, + "entry_head_history": 249192, + "final_head_history": 298384 + }, + { + "operation": "ADD", + "shape": [ + 1, + 2, + 2, + 3, + 5, + 115792089237316195423570985008687907853269984665640564039457584007913129639936 + ], + "F": 61968, + "components": 12288, + "late_overflow": false, + "steps": 1274228, + "HOME_writes": 123936, + "early_HOME_writes": 0, + "entry_head_history": 323948, + "final_head_history": 448149 + }, + { + "operation": "ADD", + "shape": [ + 1, + 1, + 1, + 1, + 6, + 1 + ], + "F": 6154, + "components": 1024, + "late_overflow": true, + "steps": 75931, + "HOME_writes": 0, + "early_HOME_writes": 0, + "entry_head_history": 212320, + "final_head_history": 224640 + }, + { + "operation": "SUB", + "shape": [ + 1, + 4, + 1, + 1, + 6, + 1 + ], + "F": 24590, + "components": 4096, + "late_overflow": false, + "steps": 500065, + "HOME_writes": 49180, + "early_HOME_writes": 0, + "entry_head_history": 249192, + "final_head_history": 298384 + }, + { + "operation": "SUB", + "shape": [ + 1, + 2, + 2, + 3, + 5, + 115792089237316195423570985008687907853269984665640564039457584007913129639936 + ], + "F": 61968, + "components": 12288, + "late_overflow": false, + "steps": 1274228, + "HOME_writes": 123936, + "early_HOME_writes": 0, + "entry_head_history": 323948, + "final_head_history": 448149 + }, + { + "operation": "SUB", + "shape": [ + 1, + 1, + 1, + 1, + 6, + 1 + ], + "F": 6154, + "components": 1024, + "late_overflow": true, + "steps": 75931, + "HOME_writes": 0, + "early_HOME_writes": 0, + "entry_head_history": 212320, + "final_head_history": 224640 + } + ], + "negative_control": "missing initial subtraction carry gives a wrong zero-minus-zero result", + "unit_scope": "exhaustive local component-entry contract only; complete Gamma geometry supplied separately in full-field tests", + "independence": "separate sparse signed-origin CPU and unbounded integer oracle; no author interpreter/checker imported", + "history_note": "head-window counters include older blank visits, not complete unknown opaque K_entry", + "hashes": { + "add.py": "5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b", + "inputs/tape_graph.py": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "inputs/machine.py": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee" + } +} diff --git a/research/source-bound-signed-home-add/review/ROOT-REVIEW.md b/research/source-bound-signed-home-add/review/ROOT-REVIEW.md new file mode 100644 index 0000000000..26e0dea104 --- /dev/null +++ b/research/source-bound-signed-home-add/review/ROOT-REVIEW.md @@ -0,0 +1,71 @@ +# Independent review of the signed packed HOME primitive + +Reviewed against canonical `e54523517d0f03e58352e647c403a5af3e525a57`. +The author graph `add.py` has SHA256 +`5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b`. +The graph was not changed after this review. This is a separate AI review, +not independent human review or formal-kernel acceptance. + +## Mathematical review + +The fifth Gamma code supplies the width physically. Its unary prefixes sum +to less than the final width, so repeated doubling costs O(w). The other +five values are inspected as encoded strings; their numeric values are not +used as uncharged loop bounds. Complete admitted DATA is divided into w-bit +components using the physical width guide. + +For subtraction, the graph complements the source bits and supplies initial +carry one. It never forms the negation of the signed minimum in width w. +At each bit the usual carry induction gives the low residue of target minus +source; the final original operand signs and result sign give the exact +signed-overflow decision. Only the final MSB decision is binding. Header and +source preservation follow directly from the write instructions. + +All arithmetic occurs on B1 working copies. The only route to HOME scatter +is the successful primitive return. Thus late overflow preserves every HOME +although private work may remain dirty. Successful returns erase the unary +guides, restore operand/private heads, and leave only permanent origins. +The conservative 4096(F+1) primitive time and 8(F+2) history increment cover +the finite loops. B1 delivery, earlier history and supplied frame/grid/packet +construction are still separate obligations. + +The current selected application's sections 2 and 4 were checked at their +exact source pin. Exterior rational coefficients are unchanged with column +multiplicity. The source -1 contacts therefore mean subtraction for even f +as well as odd f. Native phase tensoring is a distinct convention. This +binding does not establish the actual packet producer or full caller. + +## Executed independent checks + +`check_signed_add_root.py` uses a separate sparse-tape interpreter with +signed, distinct origins and opaque left/far sentinels. It does not import +the author interpreter or checker. Expected arithmetic uses unbounded +integers and one final signed-range decision. The graph builder itself is +loaded from source bytes; its retained inputs are pinned by the builder. + +The checker exhausts all signed source/target pairs for widths 2 through 6, +both operations: 10,912 local component-entry cases. These are component +contract checks, not complete Gamma packet executions. It separately runs +six genuine complete packets, including 4,096 and 12,288 components, both +signs, nontrivial r/P/S, and a 257-bit cutoff. Four successful runs restore +all six heads and private bodies and have zero early HOME writes. Two late +true overflows reject after private arithmetic with zero HOME writes. +A mutated subtraction graph missing its initial carry fails zero minus zero. + +The exact selected archive was also re-extracted read-only by the author +replay at publication review: its full gzip and canonical word hashes, +five contacts, and qualified owned-lifetime endpoints passed. The retained +source review's Git blob and bytes were checked against canonical main. +The two author identity fixtures start at already-reserved typed body entry; +they do not create full #7423 compiler addresses or selected productive width. + +From the repository root: + +```sh +python3 -I -W error -B research/source-bound-signed-home-add/review/check_signed_add_root.py +``` + +Expected marker: `PASS_ROOT_SIGNED_HOME_ADD_REVIEW`; the complete receipt is +`review/RESULT.json`. The author replay and optimized replay are documented +separately. No new kappa or discharge of a complete framework assumption is +claimed. diff --git a/research/source-bound-signed-home-add/review/check_signed_add_root.py b/research/source-bound-signed-home-add/review/check_signed_add_root.py new file mode 100644 index 0000000000..3e0ec3a664 --- /dev/null +++ b/research/source-bound-signed-home-add/review/check_signed_add_root.py @@ -0,0 +1,104 @@ +"""Separate sparse CPU and integer oracle; no author interpreter/checker.""" +from pathlib import Path +from types import ModuleType +import copy,hashlib,json,sys +P=Path(sys.argv[1]).resolve() if len(sys.argv)>1 else Path(__file__).resolve().parents[1] +A=ModuleType('root_checked_signed_add');A.__file__=str(P/'add.py');sys.modules[A.__name__]=A +exec(compile((P/'add.py').read_bytes(),str(P/'add.py'),'exec'),A.__dict__) +def need(ok,why): + if not ok:raise ValueError(why) +def word(x,w):return format(x%(1<=origins[t],'origin crossed') + low[t]=min(low[t],heads[t]);high[t]=max(high[t],heads[t]) + pc=chosen.target;steps+=1;need(steps<=budget,'bounded separate CPU exhausted') + for t,o in enumerate(origins):need(tapes[t].get(o)=='^' and tapes[t].get(o-4)=='1' and tapes[t].get(o+1000000)=='0','opaque/origin preservation') + def read(t,n):return ''.join(tapes[t].get(origins[t]+i,'_') for i in range(n)) + if not rejected: + need(heads==origins,'successful head return') + for t in ((0,A.L,A.W,A.B) if unit else range(1,6)): + o=origins[t];need(set(tapes[t])=={o,o-4,o+1000000},'private retirement') + return dict(read=read,rejected=rejected,reject_state=pc,writes=writes,early=early,steps=steps, + entry_head_history=entry,final_head_history=sum(b-a+1 for a,b in zip(low,high))) +def unit_graph(operation): + g=A.D.Graph();stages={};A.primitive(g,operation,2,'HALT',stages);g.start=stages['component_entry'];g.validate();return g,stages +def complete_case(operation,shape,late=False): + f,r,p,s,w,cutoff=shape;n=2*r*p*s*(1<<(9*f));m=1<<(w-1) + values=range(-m,m) if w==6 else (-m,-m+1,-1,0,1,m-2,m-1) + pairs=[(a,b) for a in values for b in values if -m<=(b-a if operation=='SUB' else b+a)len(target)+w,'substantial private arithmetic before overflow') + else: + outputs=[b-a if operation=='SUB' else b+a for a,b in zip(xs,ys)] + expected='^'+source+'|'+h+''.join(word(t,w) for t in outputs)+'|$' + need(not z['rejected'] and z['read'](0,len(expected))==expected,'full scientific fields') + need(z['writes'][0]==2*len(source) and z['early']==0,'post-return scatter only') + need(z['steps']<=4096*(len(source)+1),'conservative complete two-HOME bound') + return dict(operation=operation,shape=shape,F=len(source),components=n,late_overflow=late, + steps=z['steps'],HOME_writes=z['writes'][0],early_HOME_writes=z['early'], + entry_head_history=z['entry_head_history'],final_head_history=z['final_head_history']) +def main(): + units=[] + for operation in ('ADD','SUB'): + g,stages=unit_graph(operation) + for w in range(2,7): + m=1<<(w-1);count=failures=0 + for source in range(-m,m): + for target in range(-m,m): + initial={A.S:'^'+word(source,w)+'|',A.T:'^'+word(target,w)+'|',A.W:'^'+'1'*w} + z=cpu(g,initial,stages,unit=True,budget=10000);value=target-source if operation=='SUB' else target+source;fit=-m<=value 1 and + any(life["rises"][0] < j < life["rises"][-1] for j in life["writes"] + life["reads"])] + result = dict(events=len(word["program"]), public=public, owned_roles=word["owned_fields"], + lifetimes=len(lives), owned_peak=peak, dirty_clears=dirty_clears, + paid=dict(sorted(paid.items())), paid_mass=sum(rank * count for rank, count in paid.items()), + owned_rises=len(rises), ascent_histogram=dict(sorted(histogram.items())), + ascent_mass=sum(item["rank"] for item in rises), + read_before_first_rise_lifetimes=before, contacts_between_rises_lifetimes=between, + owned_reads_Y2=owned_reads_y2, strict_rejected_events=strict_rejections) + return rises, lives, result + + +def record_list(monomial): + """Uniform-in-f nine-axis record realization, with every phase retained.""" + matrix = monomial["matrix_rows"] + phase = monomial["phase"] + alpha = monomial["linear_Z4"] + quadratic = monomial["quadratic_rows"] + need(len(matrix) == len(alpha) == len(quadratic) == 9, "complete nine-axis monomial") + need(0 <= monomial["offset"] < 512 and 0 <= phase < 4, "monomial displacement/absolute phase") + records = [] + for i, value in enumerate(alpha): + need(0 <= value < 4 and value % 2 == (quadratic[i] >> i) & 1, "unit quadratic phase convention") + records.extend([["S", i]] * value) + for i in range(9): + for j in range(i + 1, 9): + need(((quadratic[i] >> j) & 1) == ((quadratic[j] >> i) & 1), "symmetric quadratic phase") + if (quadratic[i] >> j) & 1: + records.append(["CZ", i, j]) + reduced = list(matrix) + eliminate = [] + for column in range(9): + pivot = next((row for row in range(column, 9) if (reduced[row] >> column) & 1), None) + need(pivot is not None, "invertible monomial address map") + if pivot != column: + reduced[pivot], reduced[column] = reduced[column], reduced[pivot] + eliminate.extend([["XROW", column, pivot], ["XROW", pivot, column], ["XROW", column, pivot]]) + for row in range(9): + if row != column and (reduced[row] >> column) & 1: + reduced[row] ^= reduced[column] + eliminate.append(["XROW", row, column]) + need(reduced == [1 << i for i in range(9)], "monomial eliminated exactly") + records.extend(reversed(eliminate)) + records.extend(["NOT", i] for i in range(9) if (monomial["offset"] >> i) & 1) + records.extend([["I"]] * phase) + need(len(records) <= 171, "retained fixed monomial record bound") + return records + + +def load_clifford(): + spec = spec_from_file_location("owned_ascent_retained_clifford", HERE / "retained/clifford_exact.py") + module = module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def build(): + sources = authenticate() + word = json.load(gzip.open(HERE / "retained/native-word.json.gz", "rt")) + rises, lives, census = scan(word, descending_only=True) + need(len(rises) == 23 and census["ascent_mass"] == 56, "literal ascent census") + need(census["strict_rejected_events"] == [item["event"] for item in rises], "exact old-rule rejection boundary") + compiler = load_clifford() + frames = {} + + def chart(index): + if index not in frames: + frames[index] = compiler.canonical_frame(9, tuple(word["frames"][index])) + return frames[index] + + recipes = [] + for item in rises: + operator = chart(item["start"]).adjoint().then(chart(item["end"])) + recipe, compiled = compiler.lower_child(operator) + need(recipe["rank"] == item["rank"], "compiled rise is one canonical child of exactly its rank") + need(compiled.tab == operator.tab and compiled.zero_state() == operator.zero_state(), "phase-bearing compiler equality") + entry = dict(item, left=recipe["left"], right=recipe["right"]) + entry["left_records"] = record_list(entry["left"]) + entry["right_records"] = record_list(entry["right"]) + recipes.append(entry) + pairs = [len(item["left_records"]) + len(item["right_records"]) for item in recipes] + need(all(count <= 342 < 1000 for count in pairs), "every rise adapter pair fits its already charged route allowance") + controls = {} + import copy + first_birth = next(j for j, event in enumerate(word["program"]) if event[0] == "INIT") + for name, mutate in ( + ("public_alias", lambda mutant: mutant["program"][first_birth].__setitem__(1, 0)), + ("missing_clear", lambda mutant: mutant["program"].pop(next(j for j, event in enumerate(mutant["program"]) if event[0] == "CLEAR"))), + ("zero_rank_move", lambda mutant: mutant["program"][rises[0]["event"]].__setitem__(3, rises[0]["start"])), + ): + mutant = copy.deepcopy(word) + mutate(mutant) + try: + scan(mutant) + except ValueError: + controls[name] = True + else: + controls[name] = False + need(all(controls.values()), "ownership/frame controls reject") + result = dict(source_files=sources, census=census, adapter_pairs=len(recipes), + max_monomial_records=max(len(item[key]) for item in recipes for key in ("left_records", "right_records")), + max_pair_records=max(pairs), total_pair_records=sum(pairs), + existing_rise_route_allowance=1000 * len(recipes), added_paid_jobs=0, + added_productive_credits=0, added_physical_banks=0, controls=controls) + return recipes, lives, result + + +def run(): + recipes, lives, result = build() + need(json.loads(json.dumps(recipes)) == json.loads((HERE / "RECIPES.json").read_text()), "complete frozen phase-bearing recipes") + need(lives == json.loads((HERE / "LIFETIMES.json").read_text()), "complete frozen chronological lifetimes") + need(json.loads(json.dumps(result)) == json.loads((HERE / "RESULT.json").read_text())["primary"], "frozen exact result") + print(json.dumps(result, sort_keys=True)) + print("PASS_OWNED_ASCENT_CONTRACT") + + +if __name__ == "__main__": + try: + run() + except Exception as error: + print("FAIL_OWNED_ASCENT_CONTRACT:", error, file=sys.stderr) + raise SystemExit(1) from error diff --git a/research/source-bound-signed-home-add/verify.py b/research/source-bound-signed-home-add/verify.py new file mode 100644 index 0000000000..8b41a55e5b --- /dev/null +++ b/research/source-bound-signed-home-add/verify.py @@ -0,0 +1,148 @@ +"""Complete packed fields versus integers, late overflow and selected contacts.""" +from pathlib import Path +import sys,json,hashlib,subprocess,gzip +HERE=Path(__file__).resolve().parent;sys.path.insert(0,str(HERE)) +sys.dont_write_bytecode=True;sys.pycache_prefix=str(HERE/'_verify_unwritten_cache') +if Path(sys.pycache_prefix).exists():raise ValueError('verifier cache isolation path exists') +for pin in json.loads((HERE/'SOURCES.json').read_text())['files']: + raw=(HERE/pin['local']).read_bytes() + if len(raw)!=pin['bytes'] or hashlib.sha256(raw).hexdigest()!=pin['sha256']: + raise ValueError('retained input drift: '+pin['local']) +import add as A +M=A.load('signed_add_machine',HERE/'inputs/machine.py') +def need(ok,message): + if not ok:raise ValueError(message) +def gamma(n): + if n<1:raise ValueError('positive header') + return '0'*(n.bit_length()-1)+bin(n)[2:] +def header(shape):return ''.join(gamma(x) for x in shape) +def encode(xs,w):return ''.join(format(x%(1<len(a)+1,'private arithmetic did not pass the initial gather') + else: + M.Program(graph).run(state) + result=[b-a if operation=='SUB' else b+a for a,b in zip(source,target)] + need(M.fields(state)==(a,h+encode(result,w)),'source/header or complete DATA result') + M.check_retired(state) + need(state.steps<4096*(len(a)+1),'complete linear bill') + need(state.highs[-1]>=state.entry_highs[-1],'prior history dropped') + return {'operation':operation,'shape':shape,'E':len(h),'F':len(a),'components':n, + 'states':len(graph.rules),'steps':state.steps,'overflow':late,'HOME_writes':state.writes[0], + 'source_sha256':hashlib.sha256(a.encode()).hexdigest(), + 'entry_head_spans':list(zip(state.entry_lows,state.entry_highs)), + 'final_head_spans':list(zip(state.lows,state.highs))} + +def contacts(): + a=json.loads((HERE/'SOURCE-CONTACTS.json').read_text()) + expected=[(28041,['ADD',1526,1349,'-1',601]),(28129,['ADD',1526,728,'-1',601]), + (28135,['ADD',1526,729,'-1',601]),(28139,['ADD',1526,730,'-1',601]), + (28159,['ADD',1515,1526,'1',470])] + need([(x['index'],x['event']) for x in a['events'] if x['event'][0]=='ADD']==expected,'selected contacts changed') + need(a['canonical_word_sha256']=='91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097','source pin') + if '--source-repo' in sys.argv: + repo=sys.argv[sys.argv.index('--source-repo')+1];pin=a['source'] + raw=subprocess.check_output(['git','show',pin['commit']+':'+pin['path']],cwd=repo) + need(hashlib.sha256(raw).hexdigest()==pin['sha256'] and len(raw)==pin['bytes'],'source archive bytes') + word=json.loads(gzip.decompress(raw)) + need(hashlib.sha256(json.dumps(word,separators=(',',':'),sort_keys=True).encode()).hexdigest()==a['canonical_word_sha256'],'complete canonical source word') + need([(i,word['program'][i]) for i,_ in expected]==expected,'actual archive contacts') + for x in a.get('contact_owned_lifetimes',{}).values(): + need(word['program'][x['init_index']]==x['init'] and word['program'][x['clear_index']]==x['clear'],'actual owned lifetime') + return expected + +def tagged_contacts(): + """Actual raw-native identities, not invented full compiler row addresses.""" + scope=('selected-7000-raw-native','local-occurrence-0') + inp=lambda n:(scope,'native-productive-input',n) + owned=lambda n,b,e:(scope,'native-owned-lifetime',n,b,e) + bank=owned(1526,28037,37618);other=owned(1515,28153,39073) + h=header((1,1,1,1,4,1));n=1024 + tests=[(28041,'SUB',(inp(1349),bank),(0,1),[1,0]), + (28159,'ADD',(inp(0),bank,other),(1,2),[3,2,-1])] + records=[] + for index,op,owners,ports,values in tests: + payloads=tuple(h+encode([v]*n,4) for v in values) + graph,stages=A.compile_home(op,owners,ports,productive_count=1) + generic,_=A.compile_home(op,tuple(range(len(owners))),ports,productive_count=1) + need(graph.rules==generic.rules,'opaque native labels changed literal graph') + state=M.initial(payloads[:2],A.TAPES) + if len(payloads)>2: + text='^'+'|'.join(payloads)+'|$';o=state.origins[0] + state.tapes[0][o:o+len(text)]=bytes(M.SYMBOLS[c] for c in text) + state.highs[0]=state.entry_highs[0]=o+len(text)-1 + # The supplied boundary is already reserved and typed. Do not append raw + # owned zeros or claim to implement their earlier source INIT. + M.Program(graph).run(state,start=graph.execution_start) + expected=list(values);s,t=ports;expected[t]=values[t]-values[s] if op=='SUB' else values[t]+values[s] + need(M.fields(state,len(owners))==tuple(h+encode([v]*n,4) for v in expected),'native-identity source/target/parked return') + M.check_retired(state) + records.append({'event_index':index,'operation':op,'owners':owners,'operand_indices':ports, + 'productive_count':1,'K':len(owners),'body_entry':'already_reserved_and_typed', + 'steps':state.steps,'tag_relabel_graph_identical':True, + 'scope':'qualified raw-native identity; full #7423 compiler addresses are not generated'}) + return records + +def controls(): + checks=[];w=4;h=header((1,1,1,1,w,1));n=1024 + source=h+encode([1]*n,w);target=h+encode([0]*n,w) + wrong,_=A.compile_home('ADD');state=M.initial((source,target),A.TAPES);M.Program(wrong).run(state) + need(M.fields(state)!=(source,h+encode([-1]*n,w)),'wrong sign graph escaped') + checks.append('wrong_fixed_coefficient_sign') + good,_=A.compile_home('SUB');program=M.Program(good) + hs=header((1,1,1,1,w,2));ht=header((1,1,1,1,w,3)) + mismatch=M.initial((hs+encode([0]*n,w),ht+encode([0]*n,w)),A.TAPES) + try:program.run(mismatch) + except M.Rejected:need(mismatch.writes[0]==0,'header failure changed HOME') + else:raise ValueError('mismatched equal-length headers accepted') + checks.append('mismatched_equal_length_headers') + low=-(1<<(w-1));state=M.initial((h+encode([low]*n,w),h+encode([low]*n,w)),A.TAPES) + program.run(state);need(M.fields(state)[1]==h+encode([0]*n,w),'minimum-source cancellation rejected') + M.check_retired(state);checks.append('minimum_source_subtraction_cancellation') + # Literal component boundary only, not a full f2 field. The current selected + # convention leaves exterior -1 unchanged when contextual f=2 is even. + got={} + for mode in ('SUB','ADD'): + g=A.D.Graph();stages={};A.primitive(g,mode,2,'HALT',stages) + g.start=stages['component_entry'];g.validate();s=M.initial(('0','0'),A.TAPES) + for t,text in [(1,'^01|'),(2,'^00|'),(4,'^11')]: + o=s.origins[t];s.tapes[t][o:o+len(text)]=bytes(M.SYMBOLS[c] for c in text) + for t in range(1,6):s.heads[t]=s.origins[t]+1 + M.Program(g).run(s) + o=s.origins[2];bits=''.join('_01^|$'[x] for x in s.tapes[2][o+1:o+3]);v=int(bits,2) + got[mode]=v-4 if v>=2 else v + need(s.heads==s.origins,'component-boundary head return') + need(got=={'SUB':-1,'ADD':1},'even-f tensorized scalar convention escaped') + checks.append('even_f_exterior_minus_one_not_tensor_phase_component_boundary') + return checks + +def verify(): + bound=contacts();cases=[] + for operation in ('ADD','SUB'): + for w in (2,3,4,5,8,17):cases.append(run_case(operation,w)) + cases.append(run_case(operation,3,shape=(1,2,2,3,3,1))) + cases.append(run_case(operation,4,shape=(1,1,1,1,4,1<<2048))) + for w in (2,4,8):cases.append(run_case(operation,w,late=True)) + return {'marker':'PASS_SOURCE_BOUND_SIGNED_HOME_ADD','contacts':bound,'cases':cases,'controls':controls(), + 'native_identity_fixtures':tagged_contacts(),'tapes':A.TAPES, + 'scope':'fixed ±1 source contacts, same valid Γ6 headers/common grid; producer, rank2 MOVE and complete lifetime remain outside scope', + 'history_boundary':'K_entry includes opaque exterior storage and earlier history; monitored windows do not infer it.'} + +if __name__=='__main__': + r=verify();raw=json.dumps(r,indent=2,sort_keys=True)+'\n' + if '--write' in sys.argv:(HERE/'RESULT.json').write_text(raw) + elif (HERE/'RESULT.json').exists():need(json.loads((HERE/'RESULT.json').read_text())==json.loads(raw),'receipt changed') + print(raw,end='')