diff --git a/research/c511-mutable-source-boundary/ADAPTATIONS.json b/research/c511-mutable-source-boundary/ADAPTATIONS.json new file mode 100644 index 0000000000..b8f1edbaaf --- /dev/null +++ b/research/c511-mutable-source-boundary/ADAPTATIONS.json @@ -0,0 +1,168 @@ +{ + "frozen/changed/bit-native-caller/cold_cosets.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE=Path('/Users/ross/git/math')" + }, + { + "new": "RAW=BASE/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "FULL=BASE/'upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'", + "old": "FULL=BASE/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'" + }, + { + "new": "COMP=BASE/'major/bit-endpoint/BIT-FULL-COMPENSATION.json'", + "old": "COMP=BASE/'.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION.json'" + } + ], + "frozen/changed/bit-native-caller/helper_tail_retime.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE=Path('/Users/ross/git/math')" + }, + { + "new": "WORD=BASE/'major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz'", + "old": "WORD=BASE/'.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz'" + }, + { + "new": "RAW=BASE/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + } + ], + "frozen/changed/bit-native-caller/mutable_rolling_boundary.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE=Path('/Users/ross/git/math')" + }, + { + "new": "RAW=BASE/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "CODE=BASE/'old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'", + "old": "CODE=BASE/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'" + }, + { + "new": "PORTABLE.equal(p,out)", + "old": "need(json.loads(p.read_bytes())==out,'saved rolling-boundary receipt differs')" + } + ], + "frozen/changed/bit-native-caller/mutable_rolling_quotient.py": [ + { + "new": "PORTABLE.equal(p,out)", + "old": "need(json.loads(p.read_bytes())==out,'saved scalar-quotient certificate differs')" + } + ], + "frozen/changed/bit-native-caller/mutable_source_caller.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE=Path('/Users/ross/git/math')" + }, + { + "new": "RAW=BASE/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "CODE=BASE/'old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'", + "old": "CODE=BASE/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'" + }, + { + "new": "FULL=BASE/'upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'", + "old": "FULL=BASE/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'" + }, + { + "new": "PORTABLE.equal(p,out)", + "old": "need(json.loads(p.read_bytes())==out,'saved mutable-source certificate differs')" + } + ], + "frozen/changed/bit-native-caller/native_seed_binding.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE = Path('/Users/ross/git/math')" + }, + { + "new": "RAW = BASE / 'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW = BASE / 'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "OLDER = BASE / 'major'", + "old": "OLDER = BASE / '.research-automation/runs/kappa-major-20261018T1330Z'" + } + ], + "frozen/changed/bit-native-caller/physical_code.py": [ + { + "new": "BASE=PORTABLE.root/\"frozen\"", + "old": "BASE=Path('/Users/ross/git/math')" + }, + { + "new": "RAW=BASE/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "FULL=BASE/'upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'", + "old": "FULL=BASE/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'" + }, + { + "new": "OLD=BASE/'major'", + "old": "OLD=BASE/'.research-automation/runs/kappa-major-20261018T1330Z'" + }, + { + "new": "CODE=BASE/'old/root-pruned-code/BIT-PRUNED-WORD.json.gz'", + "old": "CODE=BASE/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/root-pruned-code/BIT-PRUNED-WORD.json.gz'" + } + ], + "frozen/reviews/native/independent_check.py": [ + { + "new": "ROOT=PORTABLE.root/'frozen'", + "old": "ROOT=Path('/Users/ross/git/math')" + }, + { + "new": "OLD=ROOT/'old/recursive'", + "old": "OLD=ROOT/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive'" + }, + { + "new": "RUN=ROOT/'changed/bit-native-caller'", + "old": "RUN=ROOT/'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller'" + }, + { + "new": "ROOT/'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "ROOT/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "ROOT/'upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'", + "old": "ROOT/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'" + }, + { + "new": "PORTABLE.equal(path,out)", + "old": "need(json.loads(path.read_text())==out,'complete independent receipt differs')" + } + ], + "frozen/reviews/observation/independent_check.py": [ + { + "new": "BASE = PORTABLE.root/'frozen'", + "old": "BASE = Path('/Users/ross/git/math')" + }, + { + "new": "'changed/bit-native-caller'", + "old": "'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller'" + }, + { + "new": "'upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "old": "'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "new": "'upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'", + "old": "'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz'" + }, + { + "new": "'old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'", + "old": "'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz'" + }, + { + "new": "PORTABLE.equal(HERE/'INDEPENDENT-RESULT.json',result)", + "old": "(HERE/'INDEPENDENT-RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\\n')" + } + ] +} diff --git a/research/c511-mutable-source-boundary/FROZEN-SHA256.json b/research/c511-mutable-source-boundary/FROZEN-SHA256.json new file mode 100644 index 0000000000..6e1b321abe --- /dev/null +++ b/research/c511-mutable-source-boundary/FROZEN-SHA256.json @@ -0,0 +1,24 @@ +{ + "frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json": "52d9be097f9aa84093db8292b25b4a59a329d5fb7776987b597944e7613e5bef", + "frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json": "2bd0d36a8f006ea56b0ead0be7239d474a8729f5eca032da9b4158a5428e3ea6", + "frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json": "ccd6d8386223878c3a34307715ebf7236de25eeabbeaca36f9fd77d0eb1fda95", + "frozen/changed/bit-native-caller/MUTABLE-SOURCE.md": "8e5b4b59738df394b115e1d4d3ce38524fd9f6f84222c15b0b2979404d05dfd2", + "frozen/changed/bit-native-caller/cold_cosets.py": "b266d71551ea82a767029727bf2ce6b594d0f5b4d49719a146abbe6348a7d050", + "frozen/changed/bit-native-caller/global_kernel_boost.py": "22773bd9f955130ca3c1fe2fa2c047ee7d831759df08567e2a6c987349b18272", + "frozen/changed/bit-native-caller/helper_tail_retime.py": "815f20725a20ea05064695064f4b34c4e4e6e6feaa7e42dfceb1e7031d4fed1d", + "frozen/changed/bit-native-caller/kernel_entrances.py": "921f18dc02df3a799a4fae60aa861b1f7e908957b01b81dd395f5cd8dac222cc", + "frozen/changed/bit-native-caller/mutable_rolling_boundary.py": "5469c0d50ce2bbafa21e7233e703988c140c2e90f5a1b96f7761e6e477a59e35", + "frozen/changed/bit-native-caller/mutable_rolling_quotient.py": "58d6a16c5625fcbbcf11131a6042203f8e00afa96b59cfcfd65b1a4f1a0469aa", + "frozen/changed/bit-native-caller/mutable_rolling_search.py": "b35205b2313f85b06066806aac85b8cae5664e168cdb6ba489cf55453839b993", + "frozen/changed/bit-native-caller/mutable_source_caller.py": "10e00404944ec6607f80bc698b7bed117c31f0e100ffc3403bc8ff339590959a", + "frozen/changed/bit-native-caller/native_seed_binding.py": "2bbb0b1a1fb449423a92b45e3b3fef2b328e957b6c8d0813efb2473f43fc28a6", + "frozen/changed/bit-native-caller/old_kernel_boost.py": "71070cceb72b089d745f080e642dce26c1404508411288265b6bf3f4a004ea20", + "frozen/changed/bit-native-caller/physical_code.py": "1188b1884a1d8b6873ea118d39f17f939f9e78ca778fa2a821d8a8fe2fd3d043", + "frozen/old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz": "ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847", + "frozen/reviews/native/RESULT.json": "ef67ff981f9e1c0ce178b3bc16db1a396c7fb696b6dabcf98cc97fb1014b0138", + "frozen/reviews/native/independent_check.py": "6c888137a6de434a748eff253164313b0cec90dd98043e76a1fedba77db26400", + "frozen/reviews/observation/INDEPENDENT-RESULT.json": "e1764f6492303f3ba6214a24b68301cb623ff7d2a0420e684b61fb9f2bee8adf", + "frozen/reviews/observation/independent_check.py": "fe46c6de63fff8039a91ffe96c3460ad4aab4153d21c499e63d2118c43b78c71", + "frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "frozen/upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" +} diff --git a/research/c511-mutable-source-boundary/ORIGINS.json b/research/c511-mutable-source-boundary/ORIGINS.json new file mode 100644 index 0000000000..8529ede194 --- /dev/null +++ b/research/c511-mutable-source-boundary/ORIGINS.json @@ -0,0 +1,134 @@ +[ + { + "bytes": 7569, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/cold_cosets.py", + "retained": "frozen/changed/bit-native-caller/cold_cosets.py", + "sha256": "b266d71551ea82a767029727bf2ce6b594d0f5b4d49719a146abbe6348a7d050" + }, + { + "bytes": 15496, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/global_kernel_boost.py", + "retained": "frozen/changed/bit-native-caller/global_kernel_boost.py", + "sha256": "22773bd9f955130ca3c1fe2fa2c047ee7d831759df08567e2a6c987349b18272" + }, + { + "bytes": 7405, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/helper_tail_retime.py", + "retained": "frozen/changed/bit-native-caller/helper_tail_retime.py", + "sha256": "815f20725a20ea05064695064f4b34c4e4e6e6feaa7e42dfceb1e7031d4fed1d" + }, + { + "bytes": 10050, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/kernel_entrances.py", + "retained": "frozen/changed/bit-native-caller/kernel_entrances.py", + "sha256": "921f18dc02df3a799a4fae60aa861b1f7e908957b01b81dd395f5cd8dac222cc" + }, + { + "bytes": 7778, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/mutable_rolling_boundary.py", + "retained": "frozen/changed/bit-native-caller/mutable_rolling_boundary.py", + "sha256": "5469c0d50ce2bbafa21e7233e703988c140c2e90f5a1b96f7761e6e477a59e35" + }, + { + "bytes": 5530, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/mutable_rolling_quotient.py", + "retained": "frozen/changed/bit-native-caller/mutable_rolling_quotient.py", + "sha256": "58d6a16c5625fcbbcf11131a6042203f8e00afa96b59cfcfd65b1a4f1a0469aa" + }, + { + "bytes": 4782, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/mutable_rolling_search.py", + "retained": "frozen/changed/bit-native-caller/mutable_rolling_search.py", + "sha256": "b35205b2313f85b06066806aac85b8cae5664e168cdb6ba489cf55453839b993" + }, + { + "bytes": 14815, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/mutable_source_caller.py", + "retained": "frozen/changed/bit-native-caller/mutable_source_caller.py", + "sha256": "10e00404944ec6607f80bc698b7bed117c31f0e100ffc3403bc8ff339590959a" + }, + { + "bytes": 12201, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/native_seed_binding.py", + "retained": "frozen/changed/bit-native-caller/native_seed_binding.py", + "sha256": "2bbb0b1a1fb449423a92b45e3b3fef2b328e957b6c8d0813efb2473f43fc28a6" + }, + { + "bytes": 13065, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/old_kernel_boost.py", + "retained": "frozen/changed/bit-native-caller/old_kernel_boost.py", + "sha256": "71070cceb72b089d745f080e642dce26c1404508411288265b6bf3f4a004ea20" + }, + { + "bytes": 12976, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/physical_code.py", + "retained": "frozen/changed/bit-native-caller/physical_code.py", + "sha256": "1188b1884a1d8b6873ea118d39f17f939f9e78ca778fa2a821d8a8fe2fd3d043" + }, + { + "bytes": 129639, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/MUTABLE-SOURCE-FIVE.json", + "retained": "frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json", + "sha256": "ccd6d8386223878c3a34307715ebf7236de25eeabbeaca36f9fd77d0eb1fda95" + }, + { + "bytes": 5041, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json", + "retained": "frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json", + "sha256": "52d9be097f9aa84093db8292b25b4a59a329d5fb7776987b597944e7613e5bef" + }, + { + "bytes": 81015, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json", + "retained": "frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json", + "sha256": "2bd0d36a8f006ea56b0ead0be7239d474a8729f5eca032da9b4158a5428e3ea6" + }, + { + "bytes": 8163, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/MUTABLE-SOURCE.md", + "retained": "frozen/changed/bit-native-caller/MUTABLE-SOURCE.md", + "sha256": "8e5b4b59738df394b115e1d4d3ce38524fd9f6f84222c15b0b2979404d05dfd2" + }, + { + "bytes": 42305, + "original": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "retained": "frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "bytes": 33865, + "original": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "retained": "frozen/upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 59980, + "original": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz", + "retained": "frozen/old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz", + "sha256": "ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847" + }, + { + "bytes": 18143, + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b09-native-review/independent_check.py", + "retained": "frozen/reviews/native/independent_check.py", + "sha256": "6c888137a6de434a748eff253164313b0cec90dd98043e76a1fedba77db26400" + }, + { + "bytes": 13072, + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b09-native-review/RESULT.json", + "retained": "frozen/reviews/native/RESULT.json", + "sha256": "ef67ff981f9e1c0ce178b3bc16db1a396c7fb696b6dabcf98cc97fb1014b0138" + }, + { + "bytes": 15902, + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b09-observation-review/independent_check.py", + "retained": "frozen/reviews/observation/independent_check.py", + "sha256": "fe46c6de63fff8039a91ffe96c3460ad4aab4153d21c499e63d2118c43b78c71" + }, + { + "bytes": 13479, + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b09-observation-review/INDEPENDENT-RESULT.json", + "retained": "frozen/reviews/observation/INDEPENDENT-RESULT.json", + "sha256": "e1764f6492303f3ba6214a24b68301cb623ff7d2a0420e684b61fb9f2bee8adf" + } +] diff --git a/research/c511-mutable-source-boundary/PROOF-INTERFACE.md b/research/c511-mutable-source-boundary/PROOF-INTERFACE.md new file mode 100644 index 0000000000..7e3bbc02b3 --- /dev/null +++ b/research/c511-mutable-source-boundary/PROOF-INTERFACE.md @@ -0,0 +1,242 @@ +# The fixed C511 interface and its five-call invoice + +The scientific pin is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +The fixed local word is `BIT-THREE-COPY-INPUT-WORD.json.gz`, with gzip SHA256 +`ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847`. +It uses111 source registers,111 target registers and438 ordinary helpers: +660 arbitrary independent ordinary inputs. One additional private register +is required initially zero and is erased after each of three copied totals. +The private register is not a661st arbitrary input. Its zero row is included +in every endpoint and roundtrip check. + +The scalar code C has binary rank111, defect rank `rank(C-I)=9` and exact +order511. Its literal signed source code has1487 ADDs. This is the older +C511 word; it is not the later R429 order28 code with1499 ADDs. + +## Exact local scalar contract + +In logical frame coordinates the binary VALUE endpoint is + + (x,y,h,0) -> (C x, y+C x, h,0). + +The literal inverse has binary endpoint + + (x,y,h,0) -> (C^-1 x, y+x, h,0). + +The independent checker carries all660 arbitrary ordinary input columns +as dense integer rows, plus the zero private row. It verifies both endpoints, +every old-target identity coefficient, every helper row, all private +COPY/ERASE cuts and the full signed literal-inverse roundtrip. It also +reconstructs the1487 signed source ADDs separately and compares their +entire integer matrix with the source endpoint. + +Over Z the precise endpoint has the form + + (x,y,h,0) -> (C_Z x, y+A_Z x+E_Z h, h,0), + +where `C_Z` is the literal unimodular signed code, `A_Z=C mod2` and +`E_Z=0 mod2`. The integer target block is not inferred to equal `C_Z`. +Reversing all ADDs with opposite signs and reversing the typed COPY/ERASE +word restores every ordinary integer input. Forward and raw-inverse signed +prefix row-L1 maxima are64400 and1405988; these are finite scalar bounds, +not rounded precision or native-child error bounds. + +At each COPY the source is at actual FULL and the private field is at its +actual rank-seven cap, costing rank1. The copied source remains unchanged +until ERASE, where the private and source rows are compared over Z. All +three episodes reuse the same zero private field. An omitted ERASE is +rejected when the word next attempts to modify the still-live copied source. +Changing one source-code sign preserves the full binary endpoint but changes +the integer source matrix, providing a separate signed-control witness. + +The complete coded local histogram is + + H1=1325, H2=1342, H3=79, H4=44, H5=102, H6=11, H7=9. + +It has native rank mass5061 and13283 scalar ADDs. These counts include all +three private rank-one COPY queries. The same positive rank invoice applies +to the literal inverse, whose frame path runs in the opposite direction. + +The code order is checked independently by `C^511=I`, `C^73!=I` and +`C^7!=I`. Since511=7*73, these exclude every proper divisor of511. The +five-call proof below does not use finite order511; it uses only invertibility +of C and the actual intertwiners. + +## Physical local blocks + +Let F be the local full rank-eight head/tail exchange, N the diagonal +rank-one source-line exchange and `G=F N` the rank-seven cap exchange. +F and N are commuting involutions. The source code acts separately on HEAD +and TAIL and therefore commutes with F. It does not commute with N. + +Converting the verified logical endpoint to the declared physical frames +gives, over binary VALUE operators, + + B_C = [[F C N, 0], [G C N, G]]. + +Its inverse is + + B_C^-1 = [[G C^-1,0], [F,G]]. + +For example, the lower-left inverse entry is +`G*(G C N)*(N C^-1 F) = F`; the signs disappear in characteristic two. +Both complete block products are the identity using only +`F^2=N^2=I`, `FN=NF`, `FC=CF` and `C C^-1=C^-1 C=I`. +No step commutes C with N. + +These operator identities are statements about binary VALUE arrays. They +are distinct from the signed integer lift above. Ordinary helpers are +restored in logical frame coordinates. Forward helper frames run ZERO to +FULL; inverse helper frames run FULL to ZERO. For an arbitrary incoming +physical helper, interpreting its logical symbol in the declared entrance +frame gives the rank-eight physical residual in either direction. This +interpretation does not execute a free entrance query, nor does it establish +a chronological caller owner schedule matching those boundaries. + +## The actual routed charts + +The route matrices use the deterministic upstream Weyl-BFS tree on the +actual120 full E8 root lines. The independent checker selects that tree +from the root adjacency graph, reconstructs each reflection path over the +dyadic rationals and verifies all111 resulting rho hashes against the +frozen receipt. No producer geometry function is imported. + +For a port root q of norm four, put `P=q q^T/4` and `K=I-P`. +The Weyl route supplies an8-by7 matrix A with `A A^T=K` and `A^T A=I7`. +On the common core8 and one fresh7 block the chart is + + rho = [[P,A],[A^T,0]]. + +It is symmetric and involutive. With `G0=diag(K,0)`, `E=diag(0,I7)` and +`F_s=diag(P,I7)`, the exact projector identities are + + rho G0 rho = E, rho F_s rho = diag(I8,0). + +The chart also preserves the source-line projector. The checker evaluates +all these equalities at every port. A code coefficient between ports q and p +is routed by `rho_p rho_q`, acting separately on HEAD and TAIL. Consequently +each of the6465 nonzero binary C coefficients intertwines the corresponding +old-cap operators and local full operators. Thus C_s commutes with G0 and +its local F_s. Every other fresh G_t is disjoint from this chart's active +coordinates and commutes with C_s. A common full parent exchange commutes +with every HEAD/TAIL-separated route and with its literal inverse. + +The noncommutation with common N is concrete. For actual code edge(0,1), +the `(0,8)` entry of `P_0 rho_0 rho_1` is1, whereas the same entry of +`rho_0 rho_1 P_1` is0. This is an exact dyadic witness, not a formal naming +distinction. It remains nonzero in every odd ADDRESS field. The projector +equations likewise descend to odd ADDRESS fields because all denominators +are powers of two. The old local native MOVE/COPY implementations and +their guards remain inherited premises. + +## Five calls and a paid terminal decoder + +Normalize each local call by factoring out its fresh cap exchange G. +The two CLEAN orientations and the coded forward call become + + F_clean = [[I,0],[N,I]], + B_clean = [[I,N],[0,I]], + Q_C = [[N C N,0],[C N,I]]. + +The universal identity uses two arbitrary banks. Execute CLEAN forward, +CLEAN backward, CLEAN forward, and then an ordinary bank swap. Since N is +an involution, the normalized output is `diag(N,N)`. Next execute the coded +forward call and one CLEAN forward call. Acting on that diagonal gives + + F_clean Q_C diag(N,N) = diag(N C,N). + +One direct check starts with `(N x,N y)`. The coded call gives +`(N C x, C x+N y)`; the final CLEAN call adds `N(N C x)=C x` to its target, +leaving `(N C x,N y)`. This proves the identity for every invertible C; +no commutation of N and C is used. + +Let the five cap exchanges be `G0,G1,G2,G3,G4`, with C coded at stage3. +The actual chart intertwiners allow all other fresh exchanges and G0 to +pass C3. Their product is Gamma. The parent has width +`8+4*7=36`, and `Gamma N=T_parent`. Therefore the physical five-call word +is + + T_parent diag(C3,I). + +Because the full parent exchange commutes with the actual routed code, +the literal1487-ADD inverse on bank0 removes C3 at the final full parent +cut. The bank swap costs333 scalar ADDs. The word is restored on its two +arbitrary public banks in the binary VALUE/native sense, with all helper +occurrences retaining their declared logical return and physical residual +contracts. + +The independent operator oracle uses normal forms in the group ring over +F2 of `C2(F) x (C2(N) * Z(C))`. It checks both local physical inverse +products and executes the five normalized bank updates on both input +columns. This is a symbolic all-operator identity, not a sample of small +numeric matrices. The actual source/geometry binding remains finite and +separate. A control replacing the first of the three seed calls by the +coded call gives `[[0,N],[C N,0]]`, exposing the wrong-side `C N` rather +than `N C`. The actual noncommutation witness makes this distinction physical. + +## Complete failed cost invoice + +One CLEAN local call has24248 ADDs and histogram + + H1=1322, H2=1342, H3=79, H4=44, H5=102, H6=11, H7=18, + +including nine rank-seven private copies. The independent check reconstructs +that literal CLEAN word from the frozen R438 phases and verifies its +all-column endpoint and complete typed invoice. + +Four CLEAN calls plus one coded call give + + H1=6613, H2=6710, H3=395, H4=220, H5=510, H6=55, H7=81. + +The native rank mass is25545. Public progress is `2*111*36=7992`; +2190 independent ordinary helper occurrences contribute `2190*8=17520`. +The one reused private field incurs total COPY rank `4*63+3=255`. +The uncovered deficit is + + 7992 + 17520 - 25545 = -33. + +The complete scalar ADD count, including terminal decoding and the swap, is + + 4*24248 + 13283 + 1487 + 333 = 112095. + +The local five-call construction therefore fails already at zero rate. +This invoice does not become favorable by omitting the COPYs, the final +decoder or the target/source frame progress. Further owner padding and +physical costs are additional obligations, not improvements to this fixed +invoice. No positive-rate moment or exponent is supplied. + +## Source-consuming inverse + +Precode the inverse's source by C and then decode its target by C^-1. +For arbitrary source x and old target y, the exact binary physical map is + + (x,y) -> (G x, F x + C^-1 G y). + +Here the inverse first gives `(G x,F C x+G y)`; the target decoder commutes +with F but not necessarily G. Consequently the desired full output `F x` +requires all111 caller-supplied target fields to be zero. The source is +consumed into Gx. These two linked outputs come from the same111 inputs +and do not supply two independent families of public query credit. + +Crediting only the FULL output and the ordinary helper progress gives + + 111*8 + 438*8 - 5061 = -669, + +before charging the111 zero-output fields. The two1487-ADD codes and the +13283-ADD inverse total16257 scalar ADDs. Calling these codes free means +they add no native recursive query rank; it does not mean zero arithmetic, +source access or routing cost. The internal private field is separately +required zero and erased. No restored-source or restored-zero-output +interface follows from this construction. + +## Covered domain and unresolved implications + +The result comprises the exact finite C511 scalar word and lifecycle, +source-bound dyadic routes, a universal noncommutative binary composition, +and complete negative local invoices. It covers arbitrary ordinary inputs +with the stated zero-private/zero-output premises. It does not turn logical +helper restoration into physical identity restoration. No chronological +whole-owner allocation, rounded child-defect theorem, all-size source or +tape bound, formal-kernel proof or improved multiplication exponent is +claimed. The separate historical million-pair searches, rolling words and +quotient obstructions are not premises of this bounded interface result. diff --git a/research/c511-mutable-source-boundary/PROOF-OBSERVATION.md b/research/c511-mutable-source-boundary/PROOF-OBSERVATION.md new file mode 100644 index 0000000000..0829522b30 --- /dev/null +++ b/research/c511-mutable-source-boundary/PROOF-OBSERVATION.md @@ -0,0 +1,229 @@ +# Actual rolling residual and a common scalar observation floor + +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +This note concerns one source-bound raw three-call word and a precisely +specified scalar observation contract. It proves an exact counterexample and +a111-reader information lower bound. It proves no native tariff, unrestricted +routed-reader bound or new multiplication exponent. + +## Actual source and coefficient fields + +The source is the THREE-COPY C511 word, gzip SHA256 +`ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847`. +Its1487 source-only ADDs determine a binary111-by-111 matrix C with +`rank(C)=111`, `rank(C−I)=9`, and exact order511. This is distinct from the +later pruned order28 code. The independent checker executes each source input +column separately, reconstructs all entries, and checks C^511=I while C^7 and +C^73 are nonidentity. Since511=7·73, these checks establish its exact order. +The finite-order relation is not used in the three-call expansion below. + +VALUE coefficients are over F₂. The counterexample's ADDRESS coordinates are +over the odd field F101. These fields play different roles: VALUE impulses +cancel modulo two, while ADDRESS routes use dyadic matrices reduced modulo101. + +The111 retained root lines and their port order come from the pinned R438 word +(`a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022`). +The complete120-line geometry is pinned by +`1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55`. +The actual upstream breadth-first Weyl routes determine an eight-dimensional +orthogonal matrix g_p for each retained port. With root q_p, define + +`P_p = q_p q_p^T /4`, `A_p = g_p[:,1:8]`, +`rho_p = [[P_p,A_p],[A_p^T,0]]` on15 coordinates. + +These rho_p are the actual source charts; they are not newly chosen gauges. +The independent checker reconstructs the breadth-first tree with a FIFO queue +and applies each Householder reflection as an exact rank-one update. It matches +all111 saved rational rho hashes and verifies rho_p²=I. This retains source +signs and routes before reducing to F101. + +## The raw three-call residual + +Let N be the common rank-one ADDRESS exchange, N²=I. After the declared +source precode, the normalized source-consuming inverse call at stage i has +the two-bank matrix + +`S_i = [[I,0],[N C_i,I]]`. + +Both public banks are arbitrary. No initially zero target or restored-source +condition is imposed. The actual local native identity and fresh-prefix +commutations justifying this normalization belong to the source interface +proof; the following computation then occurs in the noncommutative operator +ring over F₂. + +Use S_0 forward, its bank-swapped stage1 counterpart backward, and S_2 forward. +Writing `a_i = N C_i N`, direct multiplication gives + +`R3 = [[I+a_1 C_0, N C_1], + [N(C_2+C_2 a_1 C_0+C_0), I+a_2 C_1]]`. + +The independent polynomial checker reduces only adjacent N N to I. It matches +every saved coefficient of this matrix without assuming the C_i commute or +using C_i^511=I. After factoring off the required parent FULL exchange, its +bank0 diagonal block is + +`Phi = N(I+a_1 C_0) = N+C_1 N C_0`. + +Thus the scalar rank of C−I does not identify the rank or observation needs of +this routed operator. The bank0 residual contains C_1 N C_0, with N between +codes belonging to different native stages. + +### Exact neighboring cancellation is excluded under the stated freshness + +Suppose one tries to cancel `a_(i+1) C_i` exactly. This requires +`C_(i+1)=N C_i^(-1) N`. Let G be the next fresh exchange. The actual native +family supplies `[C_i,G]=0`, `[N,G]=0`, and +`[C_(i+1),F]=0` for `F=NG`; G is invertible. Substitution into the last +commutation relation gives + +`N C_i^(-1) G = G C_i^(-1) N = C_i^(-1) N G`. + +Cancel G to obtain `[C_i^(-1),N]=0`, equivalently `[C_i,N]=0`. This contradicts +the actual source coefficient. Independently reconstructed routed edge(0,1) +has `C[0,1]=1`; the two projector-route products differ at entry(0,8), with +values1 and0. The same local code family at fresh stages retains this +noncommutation. At the initial scalar stage, distinct root projectors already +give a nonzero commutator on this off-diagonal edge. + +This excludes that exact cancellation mechanism with those freshness +relations. It excludes neither arbitrary intermediate gates nor other coupled +bank words. The earlier millions-of-pairs bounded searches are not premises +of this proof and are not independently replayed here. + +## Actual ADDRESS impulse + +Use15 ADDRESS coordinates: the common eight plus the seven fresh coordinates +used by the routed stage1 code. Pad the remaining seven fresh coordinates by +zero to embed this example in the22-coordinate three-call parent. + +At a port p, the partial exchange N acts on HEAD/TAIL pair(h,t) by + +`(h,t) -> ((I−P_p)h+P_p t, P_p h+(I−P_p)t)`. + +C_0 is the literal scalar source code. The stage1 coefficient from middle port +k to destination p is `C[p,k]` times the head/tail-separate push by +`rho_p rho_k`. For an entering HEAD vector v and TAIL0, put + +`h_k = (I−P_k)v`, `t_k = P_k v`. + +The contribution of C_1 N C_0 along a source q, middle k, destination p path +has VALUE coefficient `C[p,k] C[k,q]` and ADDRESS + +`(rho_p rho_k h_k, rho_p rho_k t_k)`. + +Add the direct N contribution at destination q and cancel equal output +impulses modulo two. For q=0 and v=e_0, the result has exactly3131 nonzero +output impulses. Exactly one has nonzero TAIL: + +`output port0, HEAD=0, TAIL=e_0, VALUE coefficient1`. + +The complete ordered output digest is +`ae0d4019d97be344e97730f586c84152eaea4fb16e83f541edadf0e22dc76eb0`. +The independent reconstruction obtains every output, rather than checking +only this witness or its total count. + +Let U be the subspace of VALUE arrays supported on TAIL0, across all ports +and banks. The admitted free alphabet uses scalar port/bank mixing and +head/tail-separate linear ADDRESS routes, so it preserves U. Its invertible +elements and their inverses preserve U, hence induce invertible maps on the +quotient by U. The displayed nonzero quotient output cannot be erased by +such an invertible terminal free decoder. This remains true when the decoder +mixes both banks: a nonzero class cannot become zero under an invertible +quotient map. This is a counterexample to the actual raw word, not a claim +about every ADDRESS operator or caller. + +## Complete common scalar readout bound + +For each j=0,...,7, give every source port q the same input ADDRESS impulse +`HEAD=e_j, TAIL0`, with an arbitrary binary VALUE coefficient x_q. For each +output port and ADDRESS with nonzero TAIL, the corresponding VALUE output is +one scalar linear form `w·x`, with `w ∈ F₂^111`. + +The independent checker constructs these coefficient rows by following each +individual source column through the actual C_0, N and routed C_1. Equal +ADDRESS paths cancel modulo two. It then sorts the rows in the saved canonical +order. The complete census is: + +| HEAD sample | Nonzero projected coefficient rows | Accumulated binary rank | +|---|---:|---:| +|e_0|3268|63| +|e_1|3051|90| +|e_2|3054|105| +|e_3|3127|105| +|e_4|3127|111| +|e_5|3125|111| +|e_6|3128|111| +|e_7|3018|111| + +There are24898 rows in total; every sample uses all111 source columns. The +complete row digest is +`607fd1d55202d616c7d50a913511c205ebe83aeb1dfec49be000beb598c725f3`. +All111 saved original witness rows are looked up by their exact sample, +destination and ADDRESS, compared entrywise, and independently shown to have +rank111 with low-bit Gaussian pivots. This independent rank engine differs +from the producer's high-bit echelon construction. + +**Theorem.** Suppose the residual admits a factorization + +`Phi = H_free + sum_(i=1)^t A_i (c_i^T tensor I_ADDRESS)`, + +where H_free preserves U, each A_i is an F₂-linear response map, and each +`c_i ∈ F₂^111` is one fixed scalar source +row, independent of ADDRESS. Each reader combines whole source arrays at +matching addresses; the same c_i must work for all inputs. The response maps +A_i may depend on ADDRESS and route their already collected reader arrays. +Then `t ≥ 111`. + +**Proof.** Restrict the input to sample j. Reader i returns +`(c_i·x) delta_(e_j,0)`. Apply A_i and project one tail-nonzero output impulse. +Its scalar output coefficient is a multiple of `c_i·x`. H_free contributes +zero to that projection because the input lies in U. Therefore every observed +coefficient row w is in `span{c_1,...,c_t}`. The complete observed row space has +dimension111, so t is at least111. This is a finite witness to an exact +necessary statement for all factorizations in the declared model. ∎ + +The readers counted here are whole-array observations with scalar port +coefficients, not individual bits and not native child queries. The theorem +does not price their acquisition, storage, ADDRESS access or restoration. In +particular, it gives no native rank111 tariff. Routed/ADDRESS-dependent reader +rows, direct access to public inputs, extra native source queries, other cuts +or a changed word alter the factorization model and remain outside this bound. + +## Controls and verification boundary + +Setting both codes to identity makes `Phi=N+N=0` identically. The independent +checker verifies cancellation on all111·8 sampled impulses using the actual +rho_p rho_p adapters. This is a positive cancellation control, not merely an +expected rank string. + +Two actual changes affect the reconstructed map. Removing the existing bit +`C_0[0,1]` while retaining C_1 and all ADDRESS routes changes a projected +coefficient row at output port3; the row's source1 bit flips and the full first +sample digest changes. Omitting the direct N term flips the source0 coefficient +of the unique tail-nonzero boundary impulse from1 to0. Neither changed word is +claimed to be an admitted construction. + +The original failed-candidate invoice had rank mass15183 and a hypothetical +deficit213 if both banks reached the required parent endpoint. The actual +counterexample prevents that coverage from being credited. The number213 is +only a failed-candidate diagnostic. It is not a positive supplier moment. + +Normal and optimized execution of the independent checker compare identical +receipts. This review does not replay the large bounded cut searches, and it +does not substitute for the root's primary producer or portable-package checks. +The five-call restored interface is a separate construction with its own +native proof and invoice. Chronological whole-helper owners, arbitrary dirty +restoration at new caller cuts, rounded errors, all-size recursion, physical +tape/access cost and an outer multiplication theorem remain separate. + +## Credit + +The source word and geometry retain their E8/R438 ancestry and source notices, +including Sagar Thakrar's transported R438 word and the predecessor THREE-COPY +source-code construction. The local mutable-source lane supplied the C511 +interface, actual chart receipt, raw residual and scalar quotient certificate. +This review independently reconstructs the source code, Weyl routes, impulse +paths, coefficient rows and noncommutative expansion. It claims no new geometry +or generic observation theorem. Prepared with substantial OpenAI Codex +assistance; Apache-2.0. Exact finite evidence and the written argument are not +formal-kernel evidence or independent human review. diff --git a/research/c511-mutable-source-boundary/README.md b/research/c511-mutable-source-boundary/README.md new file mode 100644 index 0000000000..8130bc14ca --- /dev/null +++ b/research/c511-mutable-source-boundary/README.md @@ -0,0 +1,120 @@ +# C511 mutable-source interface and raw rolling boundary + +This package completes one fixed C511 endpoint investigation. It supplies an +exact mutable-source interface, a restored five-call word with a negative +complete invoice, and an actual obstruction to its raw three-call alternative. +No positive supplier, native reader tariff or new multiplication exponent is +claimed. Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +The local source code is the older 1487-ADD, order-511 code on 111 ports. +It is distinct from the later R429 order-28 code in +[PR3645](https://github.com/CrocSwap/integer-mult-bounds/pull/3645). +Its input consists of 660 arbitrary ordinary fields and one required-zero +private field. The logical binary endpoint is `(Cx,y+Cx,h,0)`; signed integer +target residuals and the physical helper FULL frame are retained explicitly. +The local word costs 13,283 ADDs and native rank mass 5,061. + +| Result | Exact covered contract | +|---|---| +| Physical local inverse | `B_C=[[FCN,0],[GCN,G]]`, inverse `[[GC^-1,0],[F,G]]`; F commutes with C, C does not commute with N | +| Restored five-call word | Four CLEAN calls plus one coded call, paid swap and terminal code; mass 25,545, 112,095 ADDs, public/helper progress 25,512, deficit −33 | +| Source-consuming inverse | `(x,y)->(Gx,Fx+C^-1Gy)`; 111 zero targets needed for Fx, 16,257 ADDs, linked source remnants retained | +| Raw rolling boundary | Actual `Phi=N+C1*N*C0` has a nonzero TAIL output on a TAIL-zero input; invertible head/tail-separate free decoding cannot erase it | +| Common scalar observations | All 24,898 projected coefficient rows have rank 111; any factorization through fixed ADDRESS-independent scalar reader arrays needs at least 111 readers | + +The two written proofs are [PROOF-INTERFACE.md](PROOF-INTERFACE.md) and +[PROOF-OBSERVATION.md](PROOF-OBSERVATION.md). The first proves the universal +five-call operator identity and binds its actual finite native charts. The +second proves the neighboring-cancellation obstruction, explicit counterexample +and precisely scoped reader theorem. Finite exact certificates, written +all-operator arguments and formal-kernel proofs are distinct; no formal-kernel +proof is supplied. + +## Reproduce + +From the repository root with Python 3.12: + +```sh +python3.12 -B scripts/research_package.py --package research/c511-mutable-source-boundary +``` + +Expected: four mathematical stage markers, `PASS_C511_CONTROLS`, and the +registered package success marker. `VERIFY.json` declares every command and +budget. Only the standard library is needed. Original inputs are retained byte +for byte; `FROZEN-SHA256.json` binds all 22 files, `ORIGINS.json` records their +source paths and hashes, and `ADAPTATIONS.json` lists every path and receipt +adapter. Each stage authenticates all inputs before and after execution and +compares every JSON field, including types. Frozen Python is compiled directly +at optimization zero, including nested imports, rather than trusting caches. + +The two independent mathematical checkers import no producer mathematics. +They separately reconstruct all 660 ordinary input columns and the private +zero row, actual 111 Weyl-BFS charts, both physical inverse products, complete +five-call invoice, all 3,131 boundary outputs, all 24,898 coefficient rows, +111 original witnesses and 888 identity-code cancellations. Actual mutations +exercise signed code sensitivity, omitted cleanup, code order and the ADDRESS +map. Source/receipt/type/path/cached-code controls cover the portable boundary. +See [REVIEW-NATIVE.md](REVIEW-NATIVE.md), +[REVIEW-OBSERVATION.md](REVIEW-OBSERVATION.md), [REVIEW-PORTABILITY.md](REVIEW-PORTABILITY.md), and [VALIDATION.md](VALIDATION.md). + +Historical search utilities are retained only because the producer imports +their algebra definitions. Their million-pair searches are not run, required +by the proof, or represented as new theorems. Historical prose is preserved +as provenance; the current proofs state the caller premises and limitations. + +## Scope and unresolved costs + +The scalar code rank and order do not imply a low rank for the routed rolling +residual. The reader bound counts common scalar source arrays; it does not +price native acquisition, storage, ADDRESS access, restoration, or establish +an unrestricted routed-reader bound. Routed or ADDRESS-dependent readers, +direct public-input access, other cuts and changed words are outside it. + +The source-consuming variant has one input family and two linked outputs. +Its source remnant supplies no second independent public-family credit. +Its deficit is −669 before charging the 111 zero output fields. “Free” source +codes mean zero added native query rank; scalar ADDs and routing still cost. +Helper restoration is logical, with physical rank-eight progress retained. +The earlier raw candidate's hypothetical deficit 213 cannot be credited after +its endpoint fails. No whole-helper owner schedule, rounded child-error theorem, +all-size compiler, source/tape implementation or joint supplier is supplied. +The native internal MOVE/COPY machinery remains an inherited contract. + +## Sources and credit + +Sagar Thakrar's transported R438 word and the E8 carrier/source-code lineage +from eumemic, DreamingOfClouds and Ali Romman are retained. The exact raw word +and full root data have SHA256 `a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022` +and `1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55`. +The local THREE-COPY word has gzip SHA256 +`ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847`. +Original notices and exact file provenance remain in the package. + +Hanson Sun/bbMisk's [PR1522](https://github.com/CrocSwap/integer-mult-bounds/pull/1522) +shares a restored mutable-source tour across distinct BIT outputs. Ali Romman's +[PR1862](https://github.com/CrocSwap/integer-mult-bounds/pull/1862) supplies related +ordered-ring source codes and identity-target transfers for the complex +supplier. Neither generic source mutation nor ordered source coding is claimed +as new here. Chris R/Clear1nsight's +[PR3882](https://github.com/CrocSwap/integer-mult-bounds/pull/3882) has a distinct +P104 source-consuming correction and eight-residual replacement model. +Gonzalo-Mier's [PR3772](https://github.com/CrocSwap/integer-mult-bounds/pull/3772) +prices different BIT endpoint implementations in a retained schedule. These +related results neither certify nor contradict the fixed C511 claims here. +The overlap search covers PR bodies, discussions and local package notes; +it is not a novelty certificate. + +Prepared by Ross Richardson with substantial OpenAI Codex assistance and +separate AI mathematical/integrity reviews. No independent human certification +is claimed. Apache-2.0; predecessor notices retained. + +## Open next questions + +Can a changed coupled caller reach two independent required public endpoints +with a favorable complete invoice? Start with its exact physical word, zero +stock, linked remnants and literal cleanup before assigning coverage credit. +No such caller is established here. + +Can an explicit routed reader repair this residual more cheaply? State the +changed observation map and charge native acquisition, routing and restoration; +the common scalar reader theorem alone cannot answer that question. diff --git a/research/c511-mutable-source-boundary/REVIEW-NATIVE.md b/research/c511-mutable-source-boundary/REVIEW-NATIVE.md new file mode 100644 index 0000000000..af9babc09b --- /dev/null +++ b/research/c511-mutable-source-boundary/REVIEW-NATIVE.md @@ -0,0 +1,114 @@ +# Independent C511 interface review + +Verdict: **PASS within the frozen local/native-interface premises, with the +negative five-call budget retained.** No positive supplier or new kappa +follows. Prepared with substantial OpenAI Codex assistance; this is separate +AI-assisted mathematical review, not independent human certification. + +The reviewer wrote only this external directory. Original source files and +the parent's package/worktree were not modified. The independent checker +imports no producer or producer mathematical utility. It consumes the frozen +three-copy word directly and constructs its own dense integer replay, +typed lifecycle, rational geometry and operator normal forms. + +## Publication-critical distinctions + +- The word has660 arbitrary independent ordinary inputs:111 source,111 + target and438 helpers. The extra private register is REQUIRED ZERO. + A claim of661 arbitrary input columns would be false. Its zero row is + included in the checks. +- This code has1487 source ADDs and order511, unlike the later1499-ADD + R429 order28 code. Neither code's finite order is imported into the other. +- The physical block and five-call composition are over binary VALUE + operators. Source/helper signed restoration and the integer inverse are + checked separately; even integer target residuals are not discarded. +- Helper identity is logical. Forward helpers run ZERO to FULL; inverse + helpers run FULL to ZERO. Their physical rank-eight residual is retained; + a matching chronological owner schedule is not established by relabeling + arbitrary entrance dirt. +- The source-consuming inverse needs111 additional caller-zero target + fields. For arbitrary old target y its final decoded target is + `F*x+C^-1*G*y`. The source remains `G*x`, and it is linked to the full + output rather than an independent second public input family. +- "Free code" means no added native recursive query rank. The consuming + interface still costs13283+2*1487=16257 scalar ADDs and must price its + zero-output stock, source access and routing. + +## Independent checks completed + +Both commands pass and compare the same complete receipt: + + python3 -B independent_check.py + python3 -O -B independent_check.py + +The checks include: + +1. All660 ordinary columns plus the required zero private row, using dense + arbitrary-precision integer matrices. Both local orientations restore + all438 logical helper rows and the private zero row, preserve old target + identity and have the required binary source/target blocks. +2. Every actual MOVE frame, common-frame ADD, private COPY rank, source + immutability and exact signed ERASE snapshot equality in both directions. + The complete signed literal-inverse roundtrip returns every input. +3. A separately applied1487-ADD integer code agrees with the entire local + source block; its reversed signed code gives exact integer identity. +4. Rank(C)=111, rank(C-I)=9, and order511. The order proof uses511=7*73, + C^511=I and nonidentity powers73 and7, independently of the producer's + sequential511-power search. +5. All111 actual Weyl-BFS rho matrices, reconstructed from the complete + root set by choosing a BFS tree and composing its reflection paths. + Every chosen-gauge hash agrees with the frozen receipt. Exact dyadic + orthogonality, involution, cap isometry and projector intertwiners hold. +6. The per-port intertwiner proof covers all6465 nonzero binary code + coefficients. The actual edge(0,1), entry(0,8) noncommutation witness is + 1 versus0, so C/N orientation cannot be commuted away. +7. Both physical inverse products and the five-call all-input composition + in an independent group-ring normal form with F central, N involutive + and C invertible. The proof does not assume C commutes with N. +8. The CLEAN local word is independently reconstructed from raw R438 phases + and replayed on all ordinary columns, including its nine rank-seven + private copies and complete profile. Four CLEAN calls plus one coded + call give native mass25545, public7992, helper17520, private COPY rank255, + deficit−33 and112095 ADDs including decoder and swap. +9. Executed controls: omitting an ERASE fails at the actual subsequent + source modification; changing a source-code sign changes the integer + source matrix while preserving the entire binary endpoint; the formal + first-coded replacement exposes C*N instead of N*C, with actual geometry + witnessing that the distinction is nonzero. + +The full signed forward matrix digest is +`61efdf47b2209a550b5ef931da59bb0c85946c1ef87258a79332fd3edae84eb0`. +The signed raw inverse digest is +`6e177a4a0baf9f9421f9ff71b49e61e213d6e4c23c1c0fae407f4d9c9fd22e5f`. +The matrix format is661 rows by660 ordinary columns, with the final private +row zero; each comma-delimited row ends in a newline. Forward/inverse +signed prefix maxima are64400/1405988. These do not constitute a precision +or native-child error theorem. + +## Proof audit and covered scope + +`PROOF-INTERFACE.md` gives the exact local blocks, their inverse derivation, +the actual route reduction, the short universal five-call argument and both +negative invoices. The5-call parent width is36. The fresh-cap product Gamma +satisfies Gamma*N=T_parent, and the actual coded-stage intertwiners permit +the required factor movement. The1487-ADD final inverse is paid at the full +parent cut; it is not hidden in the native query count. The333-ADD bank swap +is also included. + +The local exact C511 code, signed lifecycle and finite chosen-gauge geometry +are finite checks. The noncommutative composition identity is a written +all-operator theorem and is also symbolically checked. Reduction of its +dyadic chart equations to odd ADDRESS fields is an algebraic consequence. +The old internal native MOVE/COPY implementation remains an inherited +premise. There is no formal-kernel claim. + +The historical million-pair cut searches and rolling quotient statements +are not required for this interface theorem and were deliberately not +repeated or included as new contributions. The result is not an all-word +obstruction. A changed coupled caller can reopen the deficit; no such +completion is provided here. + +The parent owns source/receipt adapters, registered replay, source history, +publication and hosted CI. Whole chronological owners, rounded children, +source/tape lowering and a stronger multiplication theorem remain outside +this review and unresolved by the stated construction. diff --git a/research/c511-mutable-source-boundary/REVIEW-OBSERVATION.md b/research/c511-mutable-source-boundary/REVIEW-OBSERVATION.md new file mode 100644 index 0000000000..8b2a4bd9f2 --- /dev/null +++ b/research/c511-mutable-source-boundary/REVIEW-OBSERVATION.md @@ -0,0 +1,50 @@ +# B09 rolling observation review + +**Verdict: PASS within the stated observation model.** No mismatch found in +the raw residual, actual boundary impulse, complete coefficient rows or111-row +information bound. + +- Reconstructed1487-ADD C by individual input-column execution: all entries + match, binary rank111, defect rank9, exact order511. This is not A28. +- Rebuilt the actual Weyl BFS with exact rank-one Householder updates. All111 + rational rho hashes match and every rho squares to identity. +- Independently expanded the three-call matrix in a free noncommutative + polynomial ring reducing only N²=I. The bank0 residual after parent factoring + is exactly `Phi=N+C1*N*C0`; no code-order relation is needed. +- Reconstructed all3131 output impulses for sourceport0/HEAD=e0, including the + sole tail-nonzero impulse at port0,HEAD0,TAIL=e0. Full digest matches. +- Reconstructed all24898 projected coefficient rows from all eight HEAD unit + samples, using individual source-column path propagation. Complete digest, + all sample summaries and111 saved original witness rows match. Independent + low-pivot elimination proves those111 original rows are independent. +- All888 identity-code cancellation checks pass. Removing actual C0[0,1] + changes a tail-nonzero row at port3 and changes the sample digest. Omitting N + flips the source0 bit of the destructive boundary impulse. +- Rational noncommutation witness matches: edge(0,1), entry(0,8), left1/right0. + The neighboring cancellation argument uses invertibility and the specified + native freshness commutations; its conclusion excludes only that mechanism. + +## Boundaries required in publication + +1. VALUE coefficients are F2; ADDRESS coordinates are F101. Do not describe + the observation rank as a rank over the ADDRESS field. +2. The same scalar source rows must be used at every ADDRESS. The count111 is + a number of common scalar reader arrays, not a native COPY/query tariff. +3. The free remainder must preserve the tail-zero subspace. The admitted + linear head/tail-separate alphabet has this property. An expanded alphabet + must be checked afresh. +4. The actual raw three-call word fails; its diagnostic213 deficit is not + available public progress. The separate restored five-call interface must + keep its own proof and invoice. +5. Do not promote finite cut searches, scalar rank(C−I)=9, or this fixed-word + quotient bound into an all-caller, routed-reader or operator-reader claim. +6. Native local/caller binding, dirty restoration, chronological owners, + precision, source access and physical/all-size transfer remain separate. + +`PROOF-OBSERVATION.md` gives the proof and exact scope. `independent_check.py` +imports no historical producer. Its source pins and exact computed data are +in `INDEPENDENT-RESULT.json`; normal/optimized comparison is in `VALIDATION.json`. +The parent owns primary replay and integration. No millions-of-pairs search was +rerun and no original or shared worktree file was changed. + +Prepared with substantial OpenAI Codex assistance; Apache-2.0. diff --git a/research/c511-mutable-source-boundary/REVIEW-PORTABILITY.md b/research/c511-mutable-source-boundary/REVIEW-PORTABILITY.md new file mode 100644 index 0000000000..da32eccac6 --- /dev/null +++ b/research/c511-mutable-source-boundary/REVIEW-PORTABILITY.md @@ -0,0 +1,35 @@ +# B09 C511 source-to-replay integrity review + +Result: no unresolved source-integrity defect in the reviewed staging snapshot. Exact hashes, stage/receipt coverage and adaptation counts are recorded in FINAL-INTEGRITY.json. This review covers the portable loader, source closure, adapters and controls. Separate native and observation reviewers own the mathematical proof obligations; root owns full registered execution and hosted CI. + +## Exact provenance and adapters + +All 22 frozen files were independently compared byte-for-byte against every ORIGINS entry. Their lengths and SHA256 values match both ORIGINS and FROZEN-SHA256, with exact manifest coverage and no symlink inputs. This includes both independent scripts and their complete receipts. The closure contains 13 Python files, five receipts, three compressed scientific inputs and one historical Markdown note. + +All 37 uniquely matched adapters were inspected: 32 relocate path assignments or path literals, and five replace stored-output equality or output writing with PORTABLE.equal. None changes a mathematical expression, coefficient, sign, loop domain, rank engine, control, formal identity or receipt field. The adapted modules compile successfully with optimization zero. Original scientific source and receipt bytes remain untouched. + +The registered producer closure includes mutable_source_caller's cold/helper/kernel/old/global/physical utilities and the rolling quotient's boundary/search/physical utilities. Source helper imports are intercepted recursively, including imports inside functions. Twelve Python modules load when all four stage entry modules are imported; native_seed_binding is additionally retained for a function-local dependency in kernel_entrances. Only the registered stage functions are run. Other retained historical entry points, their unused paths and their million-pair searches are not invoked or claimed by this package. + +Both independent checkers use only the standard library and import no producer mathematics. Native consumes the fixed three-copy word, R438 geometry, full root data and saved interface receipt. Observation consumes those same scientific inputs plus the boundary and quotient receipts. All are authenticated retained files. The native checker rebuilds the dense input map and charts; observation independently rebuilds columns and observations. Their receipt adapters are mandatory, not optional logging. + +## Execution and comparison boundary + +Portable authenticates each frozen file before and after a stage. Its direct and nested SourceFileLoader get_code path compiles the very authenticated adapted source bytes with dont_inherit=True and optimize=0, bypassing stale bytecode. The outer verifier uses explicit exceptions rather than optimization-sensitive assertions. Controls bootstrap verify.py directly from source bytes at optimize=0. + +Four mathematical stages are registered exactly once, plus controls, with declared timeout total 870 seconds. They require exactly five complete receipts: interface; rolling boundary and rolling quotient together; independent native; independent observation. The final exact compared-set check rejects missing or extra receipt coverage. Every JSON field is compared after relocation of original provenance paths, preserving scalar types. Duplicate dictionary keys created by normalization are rejected. All five receipts passed lightweight full-value comparisons and rejected a removed status field; no mathematical main was called for those integration checks. + +The two producer stages explicitly call receipt(False). Independent native receives reset arguments, leaving --write false; its stored receipt comparison is adapted to PORTABLE.equal. Independent observation's sole unconditional output write is likewise adapted. Other imported historical main functions are not called. The supported replay has no scientific-output writes or uncontrolled writes to frozen/original files. + +## Meaningful controls + +controls.py was authored for this package and passed via the actual repository run_python_replay helper in both normal and -O Python 3.12, including its private -X pycache_prefix. See FINAL-LAUNCHER-CONTROLS.log for final-snapshot evidence. All mutations are confined to a disposable relocated copy whose path includes spaces. + +The controls reject changed source bytes, changed receipt bytes, a missing C column, a changed C bit, bool-to-int substitution, an omitted scope limit, an omitted original quotient witness and a provenance-hash overwrite hidden behind a normalized path alias. They also create a timestamp/size-valid poisoned physical_code.py cache and first demonstrate that Python's ordinary loader executes it. The actual nested interface import then executes authenticated source and passes a rank sanity check; its source is recorded in Portable.executed. Cache creation uses parents=True, so private cache-prefix placement is covered. Unexpected mutation acceptance is raised outside each expected-error catch. + +## Claim limits and historical wording + +The current docs correctly state 660 arbitrary ordinary inputs plus one required-zero private register. Some preserved producer diagnostic strings say “every661 columns”; those count output rows/zero-private coverage and do not certify arbitrary dirty private input. The independent native checker explicitly uses a 661-by-660 state and independently states this domain. No source or receipt prose was silently rewritten. + +Logical helper identity is not physical identity; native residual progress, integer even leakage and the zero-private lifecycle remain explicit. The restricted observation rank is not a native acquisition tariff or a bound against arbitrary routed readers. Historical search utilities are retained as algebra dependencies, not evidence of an all-word obstruction. Inherited internal MOVE/COPY realizations, chronological owner allocation, rounded children, source/tape access and a favorable joint recurrence remain outside this source-integrity result. There is no formal-kernel or new-kappa claim. + +Full mathematical stage success and hosted CI are separate gates owned by root. This review freezes the source/adaptation/receipt integrity result at the hashes in FINAL-INTEGRITY.json; it does not substitute for those gates. diff --git a/research/c511-mutable-source-boundary/SOURCES.json b/research/c511-mutable-source-boundary/SOURCES.json new file mode 100644 index 0000000000..a6d4dd72eb --- /dev/null +++ b/research/c511-mutable-source-boundary/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "usage": "provenance" + }, + { + "path": "docs/research/research-family-status.md", + "git_blob": "9b7d65650d8fcd6247a758936b24426b40e40efa", + "sha256": "9b98ab42364e90588e90410fd2773f9bc4bf5050f514101bed0a0246881b5b7e", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "usage": "provenance" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/README.md", + "git_blob": "f94092e67129f60b2ec39b9c78ef343a17961e6b", + "sha256": "ca62c113c07282e25230cd22fabdd0affc2bf35a792b3251444e3551dab75474", + "usage": "provenance" + } + ] +} diff --git a/research/c511-mutable-source-boundary/TASK.json b/research/c511-mutable-source-boundary/TASK.json new file mode 100644 index 0000000000..bfd59df18d --- /dev/null +++ b/research/c511-mutable-source-boundary/TASK.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance; separate AI proof reviews, no independent human or formal-kernel certification.", + "scope_status": "changed", + "scope_change_reason": "User assigned reviewed publication of preserved unpublished contributions. This item completes one changed endpoint contract and its full paid accounting; it does not construct a positive coverage law.", + "actual_scope": "Fixed C511 mutable-source interface and complete negative five-call invoice; actual raw rolling counterexample and restricted111 common scalar reader floor.", + "bottleneck_link": "Determine whether source consumption or a raw rolling caller avoids the restored-source cost without losing independent public endpoint credit.", + "budget_minutes": 240, + "outcome": "completed", + "evidence": "Exact original and independent dense/operator/ADDRESS reconstructions with complete receipt comparisons and actual defect controls.", + "stop_rule": "Finish the fixed interface and restricted observation theorem; no further caller search.", + "open_questions": [ + { + "question": "Can a changed coupled caller restore independent public banks more cheaply?", + "why_it_matters": "The five-call invoice has negative deficit and the raw three-call candidate fails its endpoint.", + "first_step": "Specify the entire physical endpoint and price all source/output stock, restoration and queries.", + "blocked_by": "No complete positive changed caller is supplied." + }, + { + "question": "Can routed observations repair the actual residual at lower complete cost?", + "why_it_matters": "The111-reader theorem covers ADDRESS-independent scalar rows only.", + "first_step": "State a changed observation map with paid native acquisition and restoration.", + "blocked_by": "Routed or ADDRESS-dependent reader circuits are outside the proved factorization model." + } + ] +} diff --git a/research/c511-mutable-source-boundary/VALIDATION.md b/research/c511-mutable-source-boundary/VALIDATION.md new file mode 100644 index 0000000000..0c9c96fa8a --- /dev/null +++ b/research/c511-mutable-source-boundary/VALIDATION.md @@ -0,0 +1,34 @@ +# Validation and exact scope + +The complete registered replay passed on CPython3.12.14 at scientific commit +`b991ef6d2b71c71716f5307b71899b9a8ccdf82b`. The final publication adds only this +validation note, the completed integrity review and a README link. + + python3 -B scripts/research_package.py --package research/c511-mutable-source-boundary + +All four mathematical stages and controls passed: the original interface and +rolling certificates, independent native/interface reconstruction, independent +complete observation reconstruction and portable source/receipt controls. The +checker compares all five complete receipts and authenticates all22 frozen +inputs before and after execution. Source files remained unchanged. + +Both independent reviewers additionally ran normal and optimized checks and +compared identical complete receipts. Integrity controls passed both modes +through the actual repository launcher, including its private cache prefix. +Optimized controls also passed from a committed Git archive in a temporary path +with spaces. That export test covers controls, not a second full mathematical +replay. Source-history and metadata preflight passed at the scientific commit; +they are checked again at publication head. + +The exact final integrity snapshot binds verify.py to +`110e0391a7b6ccf251bd46fd912f133228908eebecd30bc0190cbd93e0442e14`, +controls.py to +`c7c74c8e3c75c106dd27b05c9a6457e436bbb2cda8606fea3e7163054bd01cca`, +and all37 explicit adapters to +`828ec77de42efb773f66897a47f063fa78ed46653d977e890ee35a41890afeb2`. +No frozen source, scientific field or arithmetic adapter changed after review. + +Automatic exact-head GitHub CI is reported in the PR; this local record does +not infer hosted success. No selected-result cold replay, large historical +search, physical native compiler/tape/owner experiment, formal-kernel proof or +independent human certification was performed. No new kappa follows. diff --git a/research/c511-mutable-source-boundary/VERIFY.json b/research/c511-mutable-source-boundary/VERIFY.json new file mode 100644 index 0000000000..1424105292 --- /dev/null +++ b/research/c511-mutable-source-boundary/VERIFY.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "interface" + ], + "timeout_seconds": 240, + "checks": "Fixed C511 code, three COPY/ERASE episodes, physical inverse and five-call operator identity, full local and caller invoices." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "rolling" + ], + "timeout_seconds": 240, + "checks": "Actual raw boundary and all24898 coefficient rows with111 saved witnesses, restricted reader rank and controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent-native" + ], + "timeout_seconds": 240, + "checks": "Independent660-column signed replay and zero-private lifecycle, exact111 Weyl charts,6465 intertwiners, both inverse products and full five-call invoice." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent-observation" + ], + "timeout_seconds": 120, + "checks": "Independent3131 impulse outputs,24898 coefficient rows,111 original witnesses,888 identity cancellations and actual mutations." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py" + ], + "timeout_seconds": 30, + "checks": "Frozen source/receipt, full-field scalar types, provenance path collisions and authenticated nested source execution despite poisoned bytecode." + } + ] +} diff --git a/research/c511-mutable-source-boundary/controls.py b/research/c511-mutable-source-boundary/controls.py new file mode 100644 index 0000000000..56c4ebeb5c --- /dev/null +++ b/research/c511-mutable-source-boundary/controls.py @@ -0,0 +1,104 @@ +#!/usr/bin/env python3 +"""Small rejection controls for exact C511 source and receipt binding.""" +import copy +import importlib.machinery +import importlib.util +import json +import os +from pathlib import Path +import py_compile +import shutil +import tempfile + + +ROOT = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location('c511_verify', ROOT / 'verify.py') +verify = importlib.util.module_from_spec(spec) +exec(compile((ROOT / 'verify.py').read_bytes(), str(ROOT / 'verify.py'), + 'exec', dont_inherit=True, optimize=0), verify.__dict__) + + +def reject(action, marker): + try: + action() + except ValueError as error: + verify.need(marker in str(error), 'wrong rejection: ' + str(error)) + else: + raise ValueError('mutation accepted: ' + marker) + + +def main(): + with tempfile.TemporaryDirectory(prefix='c511 controls ') as directory: + root = Path(directory) / 'relocated package' + shutil.copytree(ROOT, root, ignore=shutil.ignore_patterns('__pycache__')) + p = verify.Portable(root) + p.check_all() + folder = root / 'frozen/changed/bit-native-caller' + source = folder / 'physical_code.py' + saved = source.read_bytes() + source.write_bytes(saved + b'\n# changed source\n') + reject(p.check_all, 'frozen input changed') + source.write_bytes(saved) + receipt = folder / 'MUTABLE-SOURCE-FIVE.json' + raw = receipt.read_bytes() + receipt.write_bytes(raw + b' ') + reject(p.check_all, 'frozen input changed') + receipt.write_bytes(raw) + actual = json.loads(raw) + verify.need(p.equal(receipt, actual), 'positive receipt control') + changed = copy.deepcopy(actual) + changed['C_binary_rows'].pop() + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + changed['C_binary_rows'][0] ^= 1 + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + changed['no_new_kappa'] = 1 + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + changed['limits'].pop() + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + old_key = next(iter(changed['sources'])) + mapped_key = p.normalize(old_key) + verify.need(old_key != mapped_key, 'path alias fixture') + original_hash = changed['sources'][old_key] + changed['sources'][old_key] = 'MUTATED_PROVENANCE_HASH' + changed['sources'][mapped_key] = original_hash + reject(lambda: p.equal(receipt, changed), 'normalized key collision') + quotient = folder / 'MUTABLE-ROLLING-QUOTIENT.json' + value = json.loads(p.authenticate(quotient)) + verify.need(p.equal(quotient, value), 'positive quotient control') + value['row_echelon_certificate'].pop() + reject(lambda: p.equal(quotient, value), 'receipt mismatch') + + # First demonstrate that ordinary Python admits a matching poisoned + # cache; then load the real nested dependency through Portable. + cache = Path(importlib.util.cache_from_source(str(source))) + cache.parent.mkdir(parents=True, exist_ok=True) + poison = Path(directory) / 'poison.py' + payload = b"raise RuntimeError('POISONED_C511_CACHE')\n#" + verify.need(len(payload) < len(saved), 'cache fixture source size') + poison.write_bytes(payload + b' ' * (len(saved) - len(payload))) + info = source.stat() + os.utime(poison, ns=(info.st_atime_ns, info.st_mtime_ns)) + py_compile.compile(str(poison), cfile=str(cache), doraise=True, + invalidation_mode=py_compile.PycInvalidationMode.TIMESTAMP) + try: + exec(importlib.machinery.SourceFileLoader('cache_probe', str(source)).get_code('cache_probe'), {}) + except RuntimeError as error: + verify.need(str(error) == 'POISONED_C511_CACHE', 'wrong cache fixture failure') + else: + raise ValueError('poisoned cache fixture was not admitted') + p.install() + module = p.load('frozen/changed/bit-native-caller/mutable_source_caller.py') + verify.need(module.rank2([1, 2, 3]) == 2, 'authenticated nested source execution') + verify.need('frozen/changed/bit-native-caller/physical_code.py' in p.executed, + 'nested source was not compiled') + p.check_all() + cache.unlink() + print('PASS_C511_CONTROLS source receipt complete_columns complete_witnesses scalar_types scope_fields path_collisions poisoned_cache nested_imports') + + +if __name__ == '__main__': + main() diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json new file mode 100644 index 0000000000..29bfb39aaf --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json @@ -0,0 +1,207 @@ +{ + "actual_raw_word_control": { + "complete_output_sha256": "ae0d4019d97be344e97730f586c84152eaea4fb16e83f541edadf0e22dc76eb0", + "conclusion": "This block is not head/tail-separate. A terminal invertible code from the admitted head/tail-separate ADDRESS/port alphabet cannot make this raw rolling word a full query on both arbitrary banks.", + "first_witness": { + "HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "TAIL": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "VALUE_coefficient_mod2": 1, + "port": 0 + }, + "input_HEAD": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "input_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "input_port": 0, + "nonzero_output_impulses": 3131, + "odd_ADDRESS_field": 101, + "operator": "N+C1*N*C0, the bank0<-bank0 block of N_global*R3", + "output_impulses_with_nonzero_TAIL": 1 + }, + "arbitrary_inputs": "Both111-port public banks arbitrary; no zero target fields and no restored source premise.", + "attribution": "Pinned C511 source code/COPY word is predecessor work. This lane supplies the exact inverse, rolling equations and independently loaded actual chart impulse.", + "exact_three_call_equation": "R3=[[I+a1*C0,N*C1],[N*(C2+C2*a1*C0+C0),I+a2*C1]], a_i=N*C_i*N.", + "failed_candidate_invoice": { + "H": { + "1": 3975, + "2": 4026, + "3": 237, + "4": 132, + "5": 306, + "6": 33, + "7": 27 + }, + "admission": "REJECTED: actual operator has nonzero source/target remnants. The213 number is only a failed-candidate cost diagnostic; no public FULL coverage or positive moment is claimed.", + "arithmetic_deficit_if_operator_had_closed": 213, + "ordinary_helper_occurrences": 1314, + "ordinary_helper_width": 8, + "private_COPY_rank": 9, + "private_peak": 1, + "public_width": 22, + "rank_mass": 15183 + }, + "limits": [ + "One actual finite ADDRESS-field impulse is a destructive counterexample to this raw word, not an all-caller lower bound.", + "The universal F/B/F equations hold on every VALUE column without using a source-code polynomial relation.", + "Chronological whole-helper owners, source/tape lowering and rounded error remain independent gates." + ], + "neighbor_cancellation_obstruction": { + "control": "The source-bound C511 native receipt has an actual nonzero rational coefficient witnessing [C_i,N]!=0. Thus exact neighbor cancellation cannot occur for the unchanged fresh-stage code family.", + "derivation": "Commutation with F_(i+1), substitution and [C_i,G_(i+1)]=0 imply [C_i,N]=0.", + "hypothesis": "a_(i+1)*C_i=I, i.e. C_(i+1)=N*C_i^-1*N", + "native_freshness": "C_i commutes G_(i+1), and C_(i+1) commutes F_(i+1)=N*G_(i+1).", + "scope": "Only the displayed exact neighbor-cancellation mechanism is excluded; other joint free code gates or actual code relations remain outside this written argument." + }, + "no_new_kappa": true, + "normalized_three_call_residual": [ + [ + [ + [], + [ + 0, + 511, + 0, + 1 + ] + ], + [ + [ + 0, + 511 + ] + ] + ], + [ + [ + [ + 0, + 1 + ], + [ + 0, + 1021 + ], + [ + 0, + 1021, + 0, + 511, + 0, + 1 + ] + ], + [ + [], + [ + 0, + 1021, + 0, + 511 + ] + ] + ] + ], + "normalized_two_call_residual": [ + [ + [ + [], + [ + 0, + 511, + 0, + 1 + ] + ], + [ + [ + 0, + 511 + ] + ] + ], + [ + [ + [ + 0, + 1 + ] + ], + [ + [] + ] + ] + ], + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_code": "Actual THREE-COPY C511, not pruned A28. Each inverse call is preceded by its1487ADD free source C_i, so its physical source is G_i*x and target cross F_i*C_i*x.", + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz": "ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "status": "PASS_RAW_ROLLING_BOUNDARY_WITH_ACTUAL_NATIVE_REJECTION", + "unclosed_diagonal_terms": [ + "I+a1*C0", + "I+a2*C1" + ] +} diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json new file mode 100644 index 0000000000..472dac3f9b --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json @@ -0,0 +1,4847 @@ +{ + "ADDRESS_field": 101, + "C_order": 511, + "all_nonzero_coefficient_rows": 24898, + "attribution": "Source code and roots are pinned predecessor data. This lane computes the actual routed operator samples and exact scalar-quotient floor.", + "bound": "If the correction uses t ADDRESS-independent common scalar source rows c_i, i.e. Phi=H_free+sum_i A_i*(c_i^T tensor I_ADDRESS), every sampled coefficient row lies in span{c_i}; therefore t is at least the displayed exact binary rank.", + "complete_coefficient_rows_sha256": "607fd1d55202d616c7d50a913511c205ebe83aeb1dfec49be000beb598c725f3", + "identity_code_negative_control": "C0=C1=I gives Phi=N+N=0 on all111*8 sampled impulses, with the actual rho_p*rho_p ADDRESS adapters.", + "input_samples": "For each core coordinate j=0..7, all111 source ports carry an arbitrary VALUE coefficient on the same HEAD=e_j,TAIL0 impulse.", + "limits": [ + "No native-query cost follows from this information rank alone.", + "Routed readouts, ADDRESS-dependent source rows, direct public-input access, extra native source queries and changed coupled words are outside this factorization.", + "The samples give a lower bound for this actual raw word, not a rank9 code obstruction or all-caller lower bound." + ], + "no_new_kappa": true, + "operator": "Phi=N+C1*N*C0, an actual unclosed block of N_global*R3", + "per_sample": [ + { + "accumulated_rank": 63, + "input_HEAD_basis": 0, + "nonfree_coefficient_rows": 3268, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 90, + "input_HEAD_basis": 1, + "nonfree_coefficient_rows": 3051, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 105, + "input_HEAD_basis": 2, + "nonfree_coefficient_rows": 3054, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 105, + "input_HEAD_basis": 3, + "nonfree_coefficient_rows": 3127, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 111, + "input_HEAD_basis": 4, + "nonfree_coefficient_rows": 3127, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 111, + "input_HEAD_basis": 5, + "nonfree_coefficient_rows": 3125, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 111, + "input_HEAD_basis": 6, + "nonfree_coefficient_rows": 3128, + "nonzero_SOURCE_columns": 111 + }, + { + "accumulated_rank": 111, + "input_HEAD_basis": 7, + "nonfree_coefficient_rows": 3018, + "nonzero_SOURCE_columns": 111 + } + ], + "projected_outputs": "Every output port/ADDRESS with nonzero TAIL; such an impulse is absent from any admitted head/tail-separate free output map.", + "row_echelon_certificate": [ + { + "original_row_witness": { + "coefficient_SOURCE_row": 1364281031450268375981883671625622, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 76, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 110, + "reduced_row": 1364281031450268375981883671625622 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 745667375834477930338916844797846, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 76, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 109, + "reduced_row": 745667375834477930338916844797846 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 420571176367129553061060905975702, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 25, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 108, + "reduced_row": 420571176367129553061060905975702 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 227888122428023580164624009756566, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 25, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 107, + "reduced_row": 227888122428023580164624009756566 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 159267282707252382191578237432422, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 106, + "reduced_row": 159267282707252382191578237432422 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 872080229941564978246942081967018, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 0, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 105, + "reduced_row": 50722055329360511676195953728682 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 525309130074591671054823598068058, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 25, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 104, + "reduced_row": 35210090793724685403173583528764 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1485975326376127769826014943428502, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0, + 25 + ], + "output_port": 1 + }, + "pivot": 103, + "reduced_row": 10157050428747049293387719597226 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 155068284390874191395430580669798, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 102, + "reduced_row": 10062283708757721282578053349120 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2070839202466181082725842274750810, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 101, + "reduced_row": 2950119343492464489076148604262 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1505680090170857789839556165861270, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 76, + 0, + 0 + ], + "output_port": 2 + }, + "pivot": 100, + "reduced_row": 1770979753344688784354001049258 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 865409032159589424156957136475708, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 25, + 25 + ], + "output_port": 0 + }, + "pivot": 99, + "reduced_row": 1193357122943367828093527996656 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1979012216963470485452010633025109, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 98, + "reduced_row": 316912650057057350374175801344 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1985271336101041249538680574437717, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 97, + "reduced_row": 163115666808318434696971159308 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 616739979317472700226294587053653, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 76, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 96, + "reduced_row": 79228162514264337593543950336 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 159309064460461694903411553799526, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 76, + 0, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 95, + "reduced_row": 78921089379909099327758270208 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 611748697252973517619043237877333, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 0, + 25, + 0, + 76 + ], + "output_port": 2 + }, + "pivot": 94, + "reduced_row": 26368183283204970050607908504 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1059466916186105936643779914809238, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 76, + 0, + 25 + ], + "output_port": 1 + }, + "pivot": 93, + "reduced_row": 16031320195595048258480151722 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 613248589040009093434313723026627, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 76, + 25, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 92, + "reduced_row": 5882633038357375554804514896 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 610084907965218710579626836486485, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 76, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 91, + "reduced_row": 4659341779789759509883258636 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 613232804024526035955953525908419, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 25, + 25, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 90, + "reduced_row": 1549842900881062590794432656 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1982884713009696305588313795796163, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 76, + 76, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 89, + "reduced_row": 930872881215854455208018000 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1982889317737070288973385274694851, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 25, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 88, + "reduced_row": 309485009933935059409043536 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2436881146555144115750106525659750, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 25, + 0, + 76, + 0 + ], + "output_port": 1 + }, + "pivot": 87, + "reduced_row": 309475817578184456527740928 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1983369763776710285739684119177557, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 76, + 76, + 0 + ], + "output_port": 1 + }, + "pivot": 86, + "reduced_row": 121648160828757485421594304 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1680434060224950656924623320813875, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 76, + 25 + ], + "output_port": 0 + }, + "pivot": 85, + "reduced_row": 38685626227668133590597632 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1676235037732122190192959896858163, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 76, + 76 + ], + "output_port": 0 + }, + "pivot": 84, + "reduced_row": 19342813113834066795298816 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 919843634097663672590244470411571, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 25, + 25 + ], + "output_port": 0 + }, + "pivot": 83, + "reduced_row": 12089258425829872742957112 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 915644568083505924911912553377331, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 25, + 76 + ], + "output_port": 0 + }, + "pivot": 82, + "reduced_row": 4835703508142097694720192 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1676304630755838562290390870348083, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 0, + 0, + 76, + 76 + ], + "output_port": 1 + }, + "pivot": 81, + "reduced_row": 2417851868912839345307696 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 913915496448222481057609187695525, + "input_HEAD_basis": 1, + "output_HEAD": [ + 50, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 76, + 0, + 76, + 0 + ], + "output_port": 2 + }, + "pivot": 80, + "reduced_row": 1208925819614629174706176 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1674506018760669530239658887633829, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 0, + 25 + ], + "output_port": 1 + }, + "pivot": 79, + "reduced_row": 604462909807314587353088 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 913957277411173124529028742931621, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 76, + 0, + 25, + 0 + ], + "output_port": 2 + }, + "pivot": 78, + "reduced_row": 302231454903657293676544 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1674547800120299651826471254205605, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 76, + 0, + 0, + 25 + ], + "output_port": 1 + }, + "pivot": 77, + "reduced_row": 151115727451828646838272 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1682232931534707996362662452239269, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 25, + 0, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 76, + "reduced_row": 75557863725914323419136 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 921642409864502096000228197292965, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 25, + 0, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 75, + "reduced_row": 37778931862957161709568 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1682191151535119421842017996924069, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 76, + 0, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 74, + "reduced_row": 18889465931478580854784 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 921600628986554049220172345615525, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 76, + 0, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 73, + "reduced_row": 9444732965739290427392 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 155110066145707204895318291460710, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 76, + 0, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 72, + "reduced_row": 8854437155380584775680 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1734082824753018225619070127219626, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 0, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 71, + "reduced_row": 2951479053442795896832 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 519208660696083532087046669348442, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 25, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 70, + "reduced_row": 1770887434374651838464 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 161066195040797725438535476181232, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 25, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 69, + "reduced_row": 627189298506258989056 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2436839364805697551520070573952358, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 76, + 0, + 76, + 0 + ], + "output_port": 1 + }, + "pivot": 68, + "reduced_row": 368934881474191114240 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2441080144874030676477440684772710, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 51, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 0, + 0, + 76, + 76 + ], + "output_port": 2 + }, + "pivot": 67, + "reduced_row": 148726874094287568896 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 519234867789959053610134593065306, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 25, + 25, + 0 + ], + "output_port": 1 + }, + "pivot": 66, + "reduced_row": 74939915408811048960 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2435152141571032296831911913588720, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 76, + 76, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 65, + "reduced_row": 41505174166047866880 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2435082234226561323937622632167664, + "input_HEAD_basis": 0, + "output_HEAD": [ + 50, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 76, + 0, + 0, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 64, + "reduced_row": 19599665578316988416 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 160996287696368250945970177312752, + "input_HEAD_basis": 0, + "output_HEAD": [ + 50, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 25, + 0, + 0, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 63, + "reduced_row": 10376293541663588352 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 153311153807439872482697688135920, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 51, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 25, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 62, + "reduced_row": 5764607523034333184 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 989056453791076342151881663283094, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 25, + 0, + 0 + ], + "output_port": 4 + }, + "pivot": 61, + "reduced_row": 2882233392781361150 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2442837275459972787867604775352560, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 0, + 0, + 0, + 0 + ], + "output_port": 2 + }, + "pivot": 60, + "reduced_row": 1729382256923148288 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2435152141571036339947241132521486, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + "output_port": 3 + }, + "pivot": 59, + "reduced_row": 1152886321325359102 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 576460752303423488, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 25, + 25, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 76, + 76, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 59 + }, + "pivot": 58, + "reduced_row": 576390383559262206 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 919913369774626757624573998837299, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 0, + 0, + 25, + 25 + ], + "output_port": 1 + }, + "pivot": 57, + "reduced_row": 229683580995895344 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 613258455012551051935980706536643, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 76, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 56, + "reduced_row": 112589990684262480 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1036431132679051268236573095129615, + "input_HEAD_basis": 4, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 25, + 76 + ], + "output_port": 1 + }, + "pivot": 55, + "reduced_row": 45035996273705056 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1982873535281552587068141812638659, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 25, + 25, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 54, + "reduced_row": 31525197391593520 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1559717362350266569457138779189775, + "input_HEAD_basis": 4, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 25, + 76 + ], + "output_port": 1 + }, + "pivot": 53, + "reduced_row": 9007199254740992 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1559733145605930584577179433667855, + "input_HEAD_basis": 4, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 76, + 25 + ], + "output_port": 1 + }, + "pivot": 52, + "reduced_row": 4503599627370544 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1038496385959229956686199488153497, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 25, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 51, + "reduced_row": 2251799813685248 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1555697645480573934758181972035481, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 25, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 50, + "reduced_row": 1125899906842624 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1040450598424477833956020544161689, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 76, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 49, + "reduced_row": 562949953421312 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1555671525429274415289046754834585, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 0, + 25, + 76, + 0 + ], + "output_port": 3 + }, + "pivot": 48, + "reduced_row": 281474976710656 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1557678348740587315422543376644249, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 0, + 76 + ], + "output_port": 1 + }, + "pivot": 47, + "reduced_row": 140737488355328 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1040477090824847938641120621672601, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 25, + 76, + 0, + 0 + ], + "output_port": 2 + }, + "pivot": 46, + "reduced_row": 70368744177664 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 525335535432301609385342510820954, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0, + 25 + ], + "output_port": 3 + }, + "pivot": 45, + "reduced_row": 35185454530560 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2076913464757075216842810317853018, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 0, + 76, + 25, + 0 + ], + "output_port": 1 + }, + "pivot": 44, + "reduced_row": 21990433980416 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2070812995372221397883440020581978, + "input_HEAD_basis": 0, + "output_HEAD": [ + 50, + 0, + 0, + 0, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 0, + 25 + ], + "output_port": 2 + }, + "pivot": 43, + "reduced_row": 8797171580928 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 872127767322601782224528012057770, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 25, + 0, + 0, + 76 + ], + "output_port": 1 + }, + "pivot": 42, + "reduced_row": 4415362744320 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2076939870114869318455535043620442, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 0, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 41, + "reduced_row": 4123168604160 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 872127581635430275692856302967978, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0 + ], + "output_port": 0 + }, + "pivot": 40, + "reduced_row": 1649267539968 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 868815908432870002457488389400892, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 25, + 76 + ], + "output_port": 0 + }, + "pivot": 39, + "reduced_row": 825439027200 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 523254661710936423529209318401228, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 25, + 25, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 38, + "reduced_row": 412384083968 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2072894076062932979370040723563724, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 25, + 76, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 37, + "reduced_row": 206359855104 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 523270444007074256637602259213260, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 76, + 25, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 36, + "reduced_row": 103280590848 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2072878290888070053094984619596748, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 76, + 76, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 35, + "reduced_row": 51741032448 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 521273956203100808511232534174668, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 25, + 25, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 34, + "reduced_row": 25770393600 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2074874778680810587002010371677132, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 25, + 76, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 33, + "reduced_row": 12922732544 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 521289741389326929135848345773260, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 25, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 32, + "reduced_row": 6480199680 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2074858996396035948243032183350476, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 76, + 76, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 31, + "reduced_row": 3259056128 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1073741824, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 25, + 0, + 0, + 25, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 76, + 0, + 0, + 76, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 30 + }, + "pivot": 30, + "reduced_row": 1073741824 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1727411504793977486514998242612796, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 76, + 25 + ], + "output_port": 0 + }, + "pivot": 29, + "reduced_row": 671137792 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1730818250503269321255597434906940, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 50, + 0, + 0, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 76, + 76 + ], + "output_port": 0 + }, + "pivot": 28, + "reduced_row": 335593472 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1727411440318023397244010205189692, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 0, + 0, + 25, + 25 + ], + "output_port": 1 + }, + "pivot": 27, + "reduced_row": 139051008 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 868815842344965628299048312465724, + "input_HEAD_basis": 0, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 0, + 0, + 0, + 76, + 76 + ], + "output_port": 1 + }, + "pivot": 26, + "reduced_row": 101253120 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1730818316584958295536456233036092, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 50, + 0, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 0, + 25, + 0, + 0, + 25 + ], + "output_port": 2 + }, + "pivot": 25, + "reduced_row": 41992192 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 865409096642019473566534911481404, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 76, + 0, + 0, + 25, + 76 + ], + "output_port": 3 + }, + "pivot": 24, + "reduced_row": 21020672 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 153381061151871645922135271262192, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 51, + 0, + 50, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 76, + 0, + 76, + 0 + ], + "output_port": 4 + }, + "pivot": 23, + "reduced_row": 8749056 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 4194304, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 25, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 76, + 0, + 0, + 0, + 0, + 76, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 22 + }, + "pivot": 22, + "reduced_row": 4194304 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 872080416603461748079412450059178, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 76, + 0, + 0, + 76 + ], + "output_port": 1 + }, + "pivot": 21, + "reduced_row": 2703360 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1734129989784902589838982619225258, + "input_HEAD_basis": 0, + "output_HEAD": [ + 50, + 0, + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 0, + 76, + 0 + ], + "output_port": 2 + }, + "pivot": 20, + "reduced_row": 1392640 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1734082638102400486742802049377194, + "input_HEAD_basis": 0, + "output_HEAD": [ + 50, + 0, + 0, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 25, + 0, + 25, + 0 + ], + "output_port": 2 + }, + "pivot": 19, + "reduced_row": 835584 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 262144, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 0, + 76, + 0, + 25, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 25, + 0, + 76, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 18 + }, + "pivot": 18, + "reduced_row": 262144 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1734130175483521454113919338159274, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 76, + 0 + ], + "output_port": 0 + }, + "pivot": 17, + "reduced_row": 245760 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 65536, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 0, + 25, + 0, + 76, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 76, + 0, + 25, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 16 + }, + "pivot": 16, + "reduced_row": 65536 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 32768, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 0, + 25, + 0, + 25, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 76, + 0, + 76, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 15 + }, + "pivot": 15, + "reduced_row": 32768 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 16384, + "input_HEAD_basis": 0, + "output_HEAD": [ + 26, + 0, + 25, + 0, + 25, + 0, + 25, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 76, + 0, + 76, + 0, + 76, + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 14 + }, + "pivot": 14, + "reduced_row": 16384 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2589398046688157573239251990943081, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 25, + 0, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 13, + "reduced_row": 8192 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2592757607046729626097202769225065, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 76, + 0, + 0, + 25 + ], + "output_port": 0 + }, + "pivot": 12, + "reduced_row": 4096 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2589350696924854570449116603662953, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 51, + 0, + 0, + 0, + 0, + 50, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 0, + 76, + 0, + 0, + 76 + ], + "output_port": 0 + }, + "pivot": 11, + "reduced_row": 2048 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2592757506467882867942327749505385, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 25, + 0, + 0, + 25 + ], + "output_port": 3 + }, + "pivot": 10, + "reduced_row": 1024 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2592804859121274158248396097259625, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 0, + 0, + 51, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 25, + 0, + 76, + 0, + 0, + 25 + ], + "output_port": 3 + }, + "pivot": 9, + "reduced_row": 512 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2589398147263233519358262897489001, + "input_HEAD_basis": 1, + "output_HEAD": [ + 51, + 0, + 0, + 0, + 0, + 0, + 51, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 76, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 0, + 76, + 0, + 25, + 0 + ], + "output_port": 1 + }, + "pivot": 8, + "reduced_row": 256 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 613271454662945717308722385052611, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 25, + 76, + 0, + 0 + ], + "output_port": 1 + }, + "pivot": 7, + "reduced_row": 240 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1042531635912499996902255866825999, + "input_HEAD_basis": 4, + "output_HEAD": [ + 50, + 0, + 0, + 0, + 50, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 25, + 25 + ], + "output_port": 2 + }, + "pivot": 6, + "reduced_row": 80 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1036415348463713915987060390989071, + "input_HEAD_basis": 4, + "output_HEAD": [ + 0, + 0, + 50, + 0, + 51, + 0, + 0, + 51, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 76, + 76, + 25 + ], + "output_port": 1 + }, + "pivot": 5, + "reduced_row": 48 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 2596069508172130947062333349822703, + "input_HEAD_basis": 4, + "output_HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "output_port": 3 + }, + "pivot": 4, + "reduced_row": 16 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1982855929623799733803660893807555, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 51, + 0, + 51, + 0, + 50, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 76, + 25, + 25, + 76, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 3, + "reduced_row": 8 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1985881855729225176177634927700398, + "input_HEAD_basis": 2, + "output_HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 2, + "reduced_row": 4 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1676235005588950225218933581500878, + "input_HEAD_basis": 1, + "output_HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 1, + "reduced_row": 2 + }, + { + "original_row_witness": { + "coefficient_SOURCE_row": 1, + "input_HEAD_basis": 0, + "output_HEAD": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_TAIL": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "output_port": 0 + }, + "pivot": 0, + "reduced_row": 1 + } + ], + "sampled_coefficient_row_rank": 111, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_receipt_sha256": "ccd6d8386223878c3a34307715ebf7236de25eeabbeaca36f9fd77d0eb1fda95", + "status": "PASS_ACTUAL_ROLLING_COMMON_SCALAR_QUOTIENT_FLOOR" +} diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json new file mode 100644 index 0000000000..d32f487b38 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json @@ -0,0 +1,8663 @@ +{ + "C_binary_rows": [ + 2435152141571036339947241132521486, + 1676235005588950225218933581500878, + 1985881855729225176177634927700398, + 576460752303423479, + 2596069508172130947062333349822703, + 309485009244884317495099359, + 10140895326260170442259558318015, + 2586086145551572543258365643440255, + 2589398147263233519358262897489001, + 2592804859121274158248396097259625, + 2592757506467882867942327749505385, + 2589350696924854570449116603662953, + 2592757607046729626097202769225065, + 2589398046688157573239251990943081, + 1734130175483521454113919338159274, + 872127581635430275692856302967978, + 1734082824753018225619070127219626, + 872080229941564978246942081967018, + 1734082638102400486742802049377194, + 872080416603461748079412450059178, + 1734129989784902589838982619225258, + 872127767322601782224528012057770, + 1727411440318023397244010205189692, + 1730818316584958295536456233036092, + 865409096642019473566534911481404, + 868815842344965628299048312465724, + 1730818250503269321255597434906940, + 1727411504793977486514998242612796, + 868815908432870002457488389400892, + 865409032159589424156957136475708, + 2074858996396035948243032183350476, + 521289741389326929135848345773260, + 2074874778680810587002010371677132, + 521273956203100808511232534174668, + 2072878290888070053094984619596748, + 523270444007074256637602259213260, + 2072894076062932979370040723563724, + 523254661710936423529209318401228, + 2076939870114869318455535043620442, + 2070839202466181082725842274750810, + 519208660696083532087046669348442, + 525309130074591671054823598068058, + 2076913464757075216842810317853018, + 2070812995372221397883440020581978, + 519234867789959053610134593065306, + 525335535432301609385342510820954, + 1040477090824847938641120621672601, + 1557678348740587315422543376644249, + 1555671525429274415289046754834585, + 1040450598424477833956020544161689, + 1555697645480573934758181972035481, + 1038496385959229956686199488153497, + 1036415348463713915987060390989071, + 1559717362350266569457138779189775, + 1553616728556518518103859291114767, + 1553632511808493436610737168036367, + 1559733145605930584577179433667855, + 1036431132679051268236573095129615, + 1042531635912499996902255866825999, + 2442837275459972787867604775352560, + 153311153807439872482697688135920, + 153381061151871645922135271262192, + 2435152141571032296831911913588720, + 160996287696368250945970177312752, + 2435082234226561323937622632167664, + 161066195040797725438535476181232, + 2436839364805697551520070573952358, + 2441080144874030676477440684772710, + 2436881146555144115750106525659750, + 155110066145707204895318291460710, + 159309064460461694903411553799526, + 155068284390874191395430580669798, + 159267282707252382191578237432422, + 921600628986554049220172345615525, + 1682191151535119421842017996924069, + 921642409864502096000228197292965, + 1682232931534707996362662452239269, + 1674547800120299651826471254205605, + 913957277411173124529028742931621, + 1674506018760669530239658887633829, + 913915496448222481057609187695525, + 919913369774626757624573998837299, + 1680503778976952268902256777719347, + 1676304630755838562290390870348083, + 1676235037732122190192959896858163, + 1680434060224950656924623320813875, + 915644568083505924911912553377331, + 919843634097663672590244470411571, + 613258455012551051935980706536643, + 1982889317737070288973385274694851, + 613271454662945717308722385052611, + 1982873535281552587068141812638659, + 1982884713009696305588313795796163, + 613248589040009093434313723026627, + 1982855929623799733803660893807555, + 613232804024526035955953525908419, + 616739979317472700226294587053653, + 610084907965218710579626836486485, + 1979012216963470485452010633025109, + 1985271336101041249538680574437717, + 1978061571187198456537696014685781, + 1983369763776710285739684119177557, + 611748697252973517619043237877333, + 1059466916186105936643779914809238, + 1505680090170857789839556165861270, + 1485975326376127769826014943428502, + 989056453791076342151881663283094, + 1364281031450268375981883671625622, + 745667375834477930338916844797846, + 420571176367129553061060905975702, + 227888122428023580164624009756566 + ], + "C_defect_rank": 9, + "C_order": 511, + "C_rank": 111, + "C_source_CODE_ADDs": 1487, + "actual_native_geometry": { + "all_nonzero_C_coefficients_covered": 6465, + "all_stage_intertwining": "For coded stage s>=1, every rho_s,p G0,p rho_s,p=E_s and rho_s,p F_s,p rho_s,p=H8. Scalar C commutes commonE_s and H8, so routed C_s commutes G0 and F_s exactly. Fresh G_t for t>=1,t!=s is disjoint from rho_s support and commutes every coefficient. T_parent is a full exchange on all used axes and commutes every diag(rho,rho) ADDRESS adapter.", + "commonN_noncommutation_control": { + "ADDRESS_entry": [ + 0, + 8 + ], + "edge": [ + 0, + 1 + ], + "left": "1", + "right": "0" + }, + "ports": [ + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 0, + "rho_sha256": "045275fd94695bfbcf07404853eb28165a6afddaa0c86bced1bc24697b5f6f8d" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 1, + "rho_sha256": "dc7aa20cef213ebb471083aeac0f32852b4336ef37376a9f5acd44e89827070f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 2, + "rho_sha256": "92f07a2c521dac9488b56f5bea199dcc564dc8ad83df722c9b7ff42690ebd532" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 3, + "rho_sha256": "46f272e0c19b62206b01de5f92cba70a7e2e9750728a1fcf6df53c78a8f86311" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 4, + "rho_sha256": "cddeaf0cff7d9bd06709c7012d7613cf04eb7eda136d1e198ce1656866a55434" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 5, + "rho_sha256": "c25ed876d162922083ec10f0a8ff6a57b5979f5f4a3ff7faa33b495dcd7266a9" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 6, + "rho_sha256": "7de45f3eaa4e6e37af658ade56e07c0fb1f06de1528ab373f06a0947957f832f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 7, + "rho_sha256": "5dbcb0301f1be2864f5360f4d641602735c290daf96a9b6355f41b50fef10157" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 8, + "rho_sha256": "51baa68f01838845f78c3e87f2bfaff4770fe4dac2792658a30f17064e556b61" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 9, + "rho_sha256": "16874f1d3c429218846ce4eb3f6550f49ac0e811b6182a7a60e77be889ae7ec2" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 10, + "rho_sha256": "7a5d5c3f62db3a028d629cfa825a39b8f3e98d2e4b98f880fcc84b0a04103569" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 11, + "rho_sha256": "5f0e10520406a278a90c9513fe074cad041cc2a24b7de1648bd1727cf37bb71d" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 12, + "rho_sha256": "39387f31d0f2ee94e5650f9fc5f0f59f0f0c96718f370b3fb47dda08639b4dd3" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 13, + "rho_sha256": "89631256d1464eb901b4949b0a3293acbe0c49a95e595aa0ae0046644fdde30f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 14, + "rho_sha256": "d579231f91cd36155735f8cc94e0cdac0d57c3ca97a0e807758f25a383fc7494" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 15, + "rho_sha256": "fc0103f42e8c46daa86a678fcbbf8a72525beba7f0a3ea2169df5c3c2f1642aa" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 16, + "rho_sha256": "115a3cdfe66a4d63de7e97283ad11e7f20c3677cb6aacad9e9e43c64a02180b7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 17, + "rho_sha256": "1f935e6d2750a6f99f79573a2d6dd070701239edf9fdfa9ca2f2b0a7211a40be" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 18, + "rho_sha256": "97f501cedd9b6ee536a5193cc9fa4042ab04e5fb0f721050db51fa187d1d7eaa" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 19, + "rho_sha256": "722f86d22b4c333edab2ff5994953fd99d6b281309dbfb11a0b5862094cd8b6e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 20, + "rho_sha256": "047f65b62ede8d8aaa70a775b3b2299127c8ebdac57b201d483f2603adcd9769" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 21, + "rho_sha256": "44e027bd2e51c119f74d20ca5a0d6b4823f7376754125baf8380c6edf0a1364c" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 22, + "rho_sha256": "c1638f25897fb7146944d6964143e3d43f4bcdea08e57379e8cd41780b289a68" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 23, + "rho_sha256": "743109c64a215a59ce50668f1c5c0a0a5f64ae45b66fff6ca46bf96dc9469f06" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 24, + "rho_sha256": "4bc7f4f1060d2d042a03cd8833f4c03968c4a05465b7f3e14e9a2a46f03f63ed" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 25, + "rho_sha256": "be589b065082d43e50cb69f8f6b59ad0cdab8b9030b11984cfa70da10dea302a" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 26, + "rho_sha256": "194c5a97b582ead4fc317b7e352944edae6ae80f40b80eeb376f080ffbb6a810" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 27, + "rho_sha256": "6d135995aecd80559cad7632e41ac6e08944abfc771f1501f5f6296e16b93d94" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 28, + "rho_sha256": "4b32902c01d3db70455c77b85f35f5e98ec51f7671f78aa8e6bbf61aac354fd6" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 29, + "rho_sha256": "e8ce73e7fbfb3383bab479a0cdd31456aa246995c43610e7c2cdc1cafb0161dd" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 30, + "rho_sha256": "8cc2b529b6738bcd8d57694e94112c621031cbb8871fef8d62b9c2b5a75442a4" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 31, + "rho_sha256": "134bd4ac6de3ceb6cc1d001c3cadf94360416d770a4705d1acb07d282e85fe99" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 32, + "rho_sha256": "a4f2c0cd439301d4b8f8ea02085c7b7817fb20e112f5bb77e353ff5c3610f6f0" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 33, + "rho_sha256": "6a2935b28e9b63201e54f2bb78ad008830befb44aac1810942d3f9dcba03a6a6" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 34, + "rho_sha256": "dbbcd773f3b29f89d6f025ebdddbf6b6d7e74b78cb7572b0ffa2b3f4f722cd84" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 35, + "rho_sha256": "700253a6e1d4b0db603c96bb130990fa58ffee95db1c874e951864f7e823a486" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 36, + "rho_sha256": "1e02e79f2342dbb8ab06f40163c99f2f11d92e8ca6b14da29e9d09565e1c2b93" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 37, + "rho_sha256": "8276a17c21c550851ffdab60c653281e54704e22a0dbf57d37ed5a1192343d40" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 38, + "rho_sha256": "d2945271d6e26f574d4755f7673f323399efb00d192a19e79bab3af9e3b0aeb9" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 39, + "rho_sha256": "873f27215e8781e5080b0f47c46eea92f0d802dbe47d17232b94240c678ab382" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 40, + "rho_sha256": "a0bb5d60493f0ddf92ad46d490c2a451a0a695175a5d7c6f3539934b75f2f0c5" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 41, + "rho_sha256": "f7d0da53e99dc999ed8a5442fb5c141d3a02fe6ab897d11444015eea6723d1ae" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 42, + "rho_sha256": "066b09c4f2dc99f19d29011b5a4083fbb0c202dfc1eae9863939e6dc008d46c2" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 43, + "rho_sha256": "8979b02de7756217f5b5590c15361d444440b92a626d28e89338227a0132a0f6" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 44, + "rho_sha256": "116b9f7aaa4def010ca9108e1db2630f54e9369ae4dfb3c4882d26af7d2ab3ce" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 45, + "rho_sha256": "477a64d9dfd9ad229dc32aa50c12c5268c46528b1c9ee45e5cca86d5e8cb6e88" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 46, + "rho_sha256": "0e5229e4f9f1a45a6b6ff8fd1328e526e064b131ab1ebce463bbf94820e5799e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 47, + "rho_sha256": "6e1ccea1c302239f9b93f14f776d36f41aa91fa1df01bf6eda00a41437d06d92" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 48, + "rho_sha256": "2ce864880fabd0a3c4564e200a64783f6f97419bad3c6b8c24eda86861268cd7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 49, + "rho_sha256": "4067229e86eec48a6c8953f5db44ddbacd2b58a1fdbe17221d6e3297f0977642" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 50, + "rho_sha256": "09c9388b54e50a25be883ce85e992c5abe7b703e7f4667da1f6cef6c287fe3b7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 51, + "rho_sha256": "be88247ac3085db25dbee6ccb33427e043dc0b0df4143f7fa7b14b053ba9eeae" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 52, + "rho_sha256": "09bb86ae1eefab1adff90ef86a886063e902b3672d87581849be37c73333a59a" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 53, + "rho_sha256": "af356c97e3cb8465479b6d9d32c3f9dc7962addcc503a98725509c800cafa931" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 54, + "rho_sha256": "ce542dad37f33d62db2849409098d19cf96cbe67121039df1bb04b22fb910953" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 55, + "rho_sha256": "a446d8a1cd0d8080f6babc70e69506f3de0fe2f45be0a627f3157114cc3414b0" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 56, + "rho_sha256": "fe09743261865b89616c0803fe71f34a914cd11ce08df9a4a65f91a78f32f42c" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 57, + "rho_sha256": "65da7a86e00f4dba5bf8c315162d2e1ad2c3573cd22481378e49cb740517934e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 58, + "rho_sha256": "8d659a132782f23cc0f915e8d7c1355685767a294f66d18d9437386cce4b08dc" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 59, + "rho_sha256": "728545c23ddb7897b451b7c2e9227f26fcbd67b205e05cf1006b2c2bf946ca69" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 60, + "rho_sha256": "3bd5358d10006616ebe4552dbe41917841fb23da3fd84085678bf453b3ed5c75" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 61, + "rho_sha256": "c6fa8a470ef2c40b735c707a55b2ee89c8038b9a5d45b8ae7299b64164bdce4b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 62, + "rho_sha256": "6215458e236dd02a6407ccb4e4378deec4f724ff8014a757db254fde6e4e1661" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 63, + "rho_sha256": "6cece2785a556bda10532bb85043fb2ead2f88cb9a81b16dd9f7176fffeb631e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 64, + "rho_sha256": "99e6d71fa35f0d54dceebbaeaabf802eca4b7bc8e3d9412bce2db1db06dea53e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 65, + "rho_sha256": "b90ecf0215ce593784401113912cb203863ac5d420d6be436f78f6281394c61f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 66, + "rho_sha256": "00183ab286dc8ef94cc4b1c69da36104fd65c281c3e4ec18521b3f56ad6980f7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 67, + "rho_sha256": "db18a49e806d2bf16d915d252ec9fa049fe35805ae0621a1b675b6696d832288" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 68, + "rho_sha256": "2a255d81cf13f3c1ac14b17886ccec5d699d2dedaa837901fa796183945b5d3c" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 69, + "rho_sha256": "4ac72929cd1b9ce2a16aec54cc0a2ae803361f633241e200e2f6bd49bb127cf3" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 70, + "rho_sha256": "b7538c187aa0e70a5aa9668286e5a2a700d7d4daca599b7879836c441cb5c3dc" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 71, + "rho_sha256": "442807ca6f90ca2a85088133b64b918c0b64a435fdafa49c602e89e98fe09663" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 72, + "rho_sha256": "340fa9cf9f0b759ca8976ee3886162588011f956d49bb4dbfb10d9b257119e99" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 73, + "rho_sha256": "20915f8642170ce6d16f237377cc58d8c7fe89ada499048027d38e5727887249" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 74, + "rho_sha256": "d496cc78ad6fd17f90955f67339c24be06c378f39c2aa96f8c8e3d5bbf0296d1" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 75, + "rho_sha256": "8d65b7e4056f603c083441d1066429850960d0c7add80621feeafb851fdb000a" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 76, + "rho_sha256": "60354db88dbf4dd64f87763fbc8072e4bfb570df6bd63d6a76d5a7c4db47c311" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 77, + "rho_sha256": "79c7120470230a1e1889ab33f47f8942f642e85b24de42bb757fcff38e6b3b4b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 78, + "rho_sha256": "8e5dcb4ca7d88c0450ebb68ed10062b00a66b93b30ceca9c2eb4546b7898fe59" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 79, + "rho_sha256": "f0a18d589b52a729de00e8b6a9b693f0b4a9ff714b0995102b0e50c983d723ea" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 80, + "rho_sha256": "f94d6e3e3a53222049d14c053ec305d7b80b309f3fe04bd5f49ca66476a6b683" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 81, + "rho_sha256": "092d723b623a5079b17013f1d053642cb95127aed02bd965ee94104f6e81597b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 82, + "rho_sha256": "b6955bdd3b2abb204846496ebbdd730414273a331a35fa99650f2754c9e649c8" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 83, + "rho_sha256": "bf2df3e0a00f72e3653d29a5de844b46901a1aa7b26b33efc6f83408ef4cb026" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 84, + "rho_sha256": "cc148d06bc75292c3afbc42429fa3ac78438a9d7d5b2f114580844e1211f0019" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 85, + "rho_sha256": "6e621219612f0742f6d169e9b12367e9ad198173070a9e6665b8f6155bbc3508" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 86, + "rho_sha256": "00ab720386ad25a6a57ba2727de405597385328aa65acecda6abeb64005044a9" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 87, + "rho_sha256": "235a8bbca828d5e1bf0e4304766a4a5886c8b3eec0908c8c92a815392a48760b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 88, + "rho_sha256": "72a60ba97fd512e3cc39087610a561a4adc86af8a21458a4eb3253d41500c6c7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 89, + "rho_sha256": "d318d8cd517eb4e7cc4c167674116506e049c7c87bee526f9a916b146b6a55a5" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 90, + "rho_sha256": "512d8b1d097c1afc2676ea4ca554dee0d6090f0781882fda6fd0cbfdedb7030f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 91, + "rho_sha256": "41ee3cd73aba19cbc35e38ebb644a4d6e8f7f234fe0a2f11f690f82b0a16679b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 92, + "rho_sha256": "0ab4677d2c121b7b775be8a0d187eb78417375c0771ca65eba79ab6fd53d05a4" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 93, + "rho_sha256": "89874ccd8f7f18ef6a3c6f471c298cb4a7f67116151daaeb55214c99e73c92ec" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 94, + "rho_sha256": "4cd5d044a59b89f1e44d135e1ca5384ceb6f6c70d797de15e1dbbe466ec926ce" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 95, + "rho_sha256": "228ab0a4f6c94f5d0eae569996bb8f446ab7d80549e99578433057f0384bed5f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 96, + "rho_sha256": "42ea02576d98f66bcaccef3aa885666aec304235ef95c0efcdfc1ddab5fc4b53" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 97, + "rho_sha256": "6e8fcdf387014b729e20ab5c3d6c9be70bf90c0779a8fedbd5c2b55dd8dfdc0d" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 98, + "rho_sha256": "ab5a89261beb8f94416a5c7d869e2fe2066728f1ec0f75d7f14193fcdca8dfbc" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 99, + "rho_sha256": "50fde37047d2805f0499b380d59aa21556c67117fd866faa710757e4cb773d66" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 100, + "rho_sha256": "67edb82c64a09464c8856a56b3461fc6c751fa71f614b7c9a6679be558307c86" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 101, + "rho_sha256": "4f163a7ba2e4e7334d93220e21a2865f825d3e7c143008321e4b587c5f139a5e" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 102, + "rho_sha256": "7d966efd36d7e92b0017bc79743b4007b628d0400a143ead5d4cc9478c2003c9" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 103, + "rho_sha256": "6e0bdeb594e1f1ca8eb5beaa8c6678b1ca850c472a1e127f96ec3e878029ea6b" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 104, + "rho_sha256": "9d780b5d2f421bf544f6d492aaa9ac7c9be626218d087b22b48da69ac0160173" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 105, + "rho_sha256": "7cf18c8d742b40161e1f35e8461b8891ef5335fd8581dd7026d387360e6292a7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 106, + "rho_sha256": "d8e8a45b9d378ae74e6ab9413736ca25e887b5c3b800092d3659e4ec5cb511f7" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 107, + "rho_sha256": "0f599208fca2e75fd62ae49b624061d6e558dbf44c9376c9dcd77816c9e2922f" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 108, + "rho_sha256": "a94e3e85fc2eabbe96f4dc4afec11d3e6c48a2dbf7c3f7d9aa1568b1edff95e0" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 109, + "rho_sha256": "06b1e1d438b5ca16c78076e8dc0ceb7d8abc9bf9275909462c83b721db55e431" + }, + { + "G0_conjugate": "E_fresh7", + "local_FULL_conjugate": "I_core8", + "port": 110, + "rho_sha256": "d620282696bf3e1dab3b5224515fcb68a01afce74793f55ed7ac04e437814412" + } + ] + }, + "attribution": "C3 word and source-code/COPY ancestry are pinned predecessor work. This lane independently replays every signed local column, identifies actual order511 C, proves the mutable-source five-call identity with actual rho and supplies the complete failed budget.", + "clean_local_profile": { + "ADDs": 24248, + "COPY_records": [ + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 510, + "source_helper": 471 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 511, + "source_helper": 472 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 512, + "source_helper": 473 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 513, + "source_helper": 474 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 514, + "source_helper": 475 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 515, + "source_helper": 476 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 516, + "source_helper": 477 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 517, + "source_helper": 478 + }, + { + "private_frame": 0, + "query_rank": 7, + "source_frame": 518, + "source_helper": 479 + } + ], + "COPYs": 9, + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "mass": 5121, + "prefix_row_L1": 1890, + "private_fields": 1 + }, + "coded_literal_inverse": { + "ADDs": 13283, + "COPY_records": [ + { + "private_frame": 527, + "query_rank": 1, + "source_frame": 1, + "source_helper": 2 + }, + { + "private_frame": 526, + "query_rank": 1, + "source_frame": 1, + "source_helper": 1 + }, + { + "private_frame": 525, + "query_rank": 1, + "source_frame": 1, + "source_helper": 0 + } + ], + "COPYs": 3, + "H": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "mass": 5061, + "prefix_row_L1": 64400, + "private_fields": 1 + }, + "coded_local_profile": { + "ADDs": 13283, + "COPY_records": [ + { + "private_frame": 525, + "query_rank": 1, + "source_frame": 1, + "source_helper": 0 + }, + { + "private_frame": 526, + "query_rank": 1, + "source_frame": 1, + "source_helper": 1 + }, + { + "private_frame": 527, + "query_rank": 1, + "source_frame": 1, + "source_helper": 2 + } + ], + "COPYs": 3, + "H": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "mass": 5061, + "prefix_row_L1": 64400, + "private_fields": 1 + }, + "complete_local_call_histogram": { + "1": 6613, + "2": 6710, + "3": 395, + "4": 220, + "5": 510, + "6": 55, + "7": 81 + }, + "complete_local_scalar_ADDs_including_decoder_and_SWAP": 112095, + "contract": "Two arbitrary public DATA banks receive exact parentFULL native BIT queries; all2190 independent ordinary helper occurrences retain their exact dirty-helper return contract and one zero private field is literally erased for every COPY. Source code is removed by its actual1487ADD inverse at a full parent cut. Local scalar identities are verified on every660 public/ordinary column and the zero private column; native composition is a universal noncommutative F2 operator identity with actual rational rho intertwiners.", + "formal_all_VALUE_columns": { + "all_parameter_identity": "Gamma5 * F_clean * F_C * N_global = Gamma5 * diag(N*C,N) = T_parent * diag(C,I). The actual full parent T commutes C, so a final free physical C^-1 on bank0 gives diag(T,T).", + "clean_B": [ + [ + [ + "I" + ], + [ + "N" + ] + ], + [ + [], + [ + "I" + ] + ] + ], + "clean_F": [ + [ + [ + "I" + ], + [] + ], + [ + [ + "N" + ], + [ + "I" + ] + ] + ], + "coded_F_C": [ + [ + [ + "NCN" + ], + [] + ], + [ + [ + "CN" + ], + [ + "I" + ] + ] + ], + "first_coded_three_call_control": [ + [ + [], + [ + "N" + ] + ], + [ + [ + "CN" + ], + [] + ] + ], + "five_call_residual": [ + [ + [ + "NC" + ], + [] + ], + [ + [], + [ + "N" + ] + ] + ], + "inverse_after_free_source_C": [ + [ + [ + "I" + ], + [] + ], + [ + [ + "NC" + ], + [ + "I" + ] + ] + ], + "inverse_coded_normalized": [ + [ + [ + "c" + ], + [] + ], + [ + [ + "N" + ], + [ + "I" + ] + ] + ], + "inverse_physical_interface": "B_C^-1 = [[G*C^-1,0],[F,G]], since F=G*N, F^2=G^2=N^2=I and F commutes C. A free source C precode gives (x,y)->(G*x,F*C*x+G*y). For one full local parent F and y=0, a free target C^-1 decoder gives (G*x,F*x).", + "relations": "N^2=I only for the residual word. Every fresh G_t with t!=coded_stage commutes C_coded, proved below using actual rho. Full parent T commutes the head/tail-separate code C_coded.", + "seed_after_swap": [ + [ + [ + "N" + ], + [] + ], + [ + [], + [ + "N" + ] + ] + ] + }, + "limits": [ + "No positive-rate moment can be claimed from the D=-33 local invoice.", + "The old CLEAN R438 native child implementation remains a pinned imported premise.", + "No chronological owner, rounded child-defect or physical source/tape lowering theorem is supplied.", + "This finite/source-bound native binding is not a formal-kernel proof." + ], + "native_query_count": 14584, + "negative_controls": [ + "First-coded three-call replacement has C*N rather than N*C and fails the free-decoder orientation.", + "An actual source-code edge does not commute commonN, so the failed substitution is not merely syntactic." + ], + "no_new_kappa": true, + "ordinary_bank_SWAP_ADDs": 333, + "ordinary_helper_occurrences": 2190, + "ordinary_helper_progress": 17520, + "ordinary_helper_residual_width": 8, + "private_COPY_rank": 255, + "private_fields_peak": 1, + "public_progress": 7992, + "rank_mass": 25545, + "raw_inverse_local_profile": { + "ADDs": 13283, + "COPY_records": [ + { + "private_frame": 527, + "query_rank": 1, + "source_frame": 1, + "source_helper": 2 + }, + { + "private_frame": 526, + "query_rank": 1, + "source_frame": 1, + "source_helper": 1 + }, + { + "private_frame": 525, + "query_rank": 1, + "source_frame": 1, + "source_helper": 0 + } + ], + "COPYs": 3, + "H": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "mass": 5061, + "prefix_row_L1": 1405988, + "private_fields": 1 + }, + "recipe": { + "calls": [ + { + "helpers": "fresh438_0", + "kind": "CLEAN_F", + "source_bank": 0, + "stage": 0, + "target_bank": 1 + }, + { + "helpers": "fresh438_1", + "kind": "CLEAN_B", + "source_bank": 1, + "stage": 1, + "target_bank": 0 + }, + { + "helpers": "fresh438_2", + "kind": "CLEAN_F", + "source_bank": 0, + "stage": 2, + "target_bank": 1 + }, + { + "XOR_ADDs": 333, + "cut": "after stage2", + "kind": "ordinary bankSWAP" + }, + { + "helpers": "fresh438_3", + "kind": "C3_CODED_F", + "source_bank": 0, + "stage": 3, + "target_bank": 1 + }, + { + "helpers": "fresh438_4", + "kind": "CLEAN_F", + "source_bank": 0, + "stage": 4, + "target_bank": 1 + } + ], + "final_source_decoder": { + "address_adapter": "Each source ADD is routed by actual rho_(3,d)*rho_(3,s), acting separately on head and tail; parentFULL commutes every adapter.", + "bank": 0, + "coded_stage": 3, + "inverse_ADDs": [ + [ + 0, + 3, + 1 + ], + [ + 0, + 5, + 1 + ], + [ + 0, + 6, + 1 + ], + [ + 0, + 15, + 1 + ], + [ + 0, + 17, + 1 + ], + [ + 0, + 19, + 1 + ], + [ + 0, + 21, + 1 + ], + [ + 0, + 24, + 1 + ], + [ + 0, + 25, + 1 + ], + [ + 0, + 28, + 1 + ], + [ + 0, + 29, + 1 + ], + [ + 0, + 31, + 1 + ], + [ + 0, + 33, + 1 + ], + [ + 0, + 35, + 1 + ], + [ + 0, + 37, + 1 + ], + [ + 0, + 40, + 1 + ], + [ + 0, + 41, + 1 + ], + [ + 0, + 44, + 1 + ], + [ + 0, + 45, + 1 + ], + [ + 0, + 46, + 1 + ], + [ + 0, + 49, + 1 + ], + [ + 0, + 51, + 1 + ], + [ + 0, + 52, + 1 + ], + [ + 0, + 57, + 1 + ], + [ + 0, + 58, + 1 + ], + [ + 0, + 60, + 1 + ], + [ + 0, + 61, + 1 + ], + [ + 0, + 63, + 1 + ], + [ + 0, + 65, + 1 + ], + [ + 0, + 69, + 1 + ], + [ + 0, + 70, + 1 + ], + [ + 0, + 71, + 1 + ], + [ + 0, + 72, + 1 + ], + [ + 0, + 73, + 1 + ], + [ + 0, + 75, + 1 + ], + [ + 0, + 78, + 1 + ], + [ + 0, + 80, + 1 + ], + [ + 0, + 81, + 1 + ], + [ + 0, + 86, + 1 + ], + [ + 0, + 87, + 1 + ], + [ + 0, + 88, + 1 + ], + [ + 0, + 90, + 1 + ], + [ + 0, + 93, + 1 + ], + [ + 0, + 95, + 1 + ], + [ + 0, + 96, + 1 + ], + [ + 0, + 97, + 1 + ], + [ + 0, + 102, + 1 + ], + [ + 0, + 103, + 1 + ], + [ + 0, + 106, + 1 + ], + [ + 0, + 108, + 1 + ], + [ + 0, + 109, + 1 + ], + [ + 1, + 3, + 1 + ], + [ + 1, + 5, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 10, + 1 + ], + [ + 1, + 11, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 1, + 15, + 1 + ], + [ + 1, + 16, + 1 + ], + [ + 1, + 18, + 1 + ], + [ + 1, + 21, + 1 + ], + [ + 1, + 22, + 1 + ], + [ + 1, + 23, + 1 + ], + [ + 1, + 26, + 1 + ], + [ + 1, + 27, + 1 + ], + [ + 1, + 32, + 1 + ], + [ + 1, + 33, + 1 + ], + [ + 1, + 36, + 1 + ], + [ + 1, + 37, + 1 + ], + [ + 1, + 42, + 1 + ], + [ + 1, + 43, + 1 + ], + [ + 1, + 44, + 1 + ], + [ + 1, + 45, + 1 + ], + [ + 1, + 46, + 1 + ], + [ + 1, + 48, + 1 + ], + [ + 1, + 51, + 1 + ], + [ + 1, + 52, + 1 + ], + [ + 1, + 55, + 1 + ], + [ + 1, + 56, + 1 + ], + [ + 1, + 61, + 1 + ], + [ + 1, + 64, + 1 + ], + [ + 1, + 65, + 1 + ], + [ + 1, + 67, + 1 + ], + [ + 1, + 68, + 1 + ], + [ + 1, + 71, + 1 + ], + [ + 1, + 72, + 1 + ], + [ + 1, + 73, + 1 + ], + [ + 1, + 76, + 1 + ], + [ + 1, + 77, + 1 + ], + [ + 1, + 80, + 1 + ], + [ + 1, + 81, + 1 + ], + [ + 1, + 84, + 1 + ], + [ + 1, + 85, + 1 + ], + [ + 1, + 90, + 1 + ], + [ + 1, + 91, + 1 + ], + [ + 1, + 94, + 1 + ], + [ + 1, + 95, + 1 + ], + [ + 1, + 96, + 1 + ], + [ + 1, + 97, + 1 + ], + [ + 1, + 98, + 1 + ], + [ + 1, + 99, + 1 + ], + [ + 1, + 100, + 1 + ], + [ + 1, + 101, + 1 + ], + [ + 1, + 102, + 1 + ], + [ + 1, + 103, + 1 + ], + [ + 1, + 105, + 1 + ], + [ + 1, + 107, + 1 + ], + [ + 1, + 109, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 13, + 1 + ], + [ + 2, + 16, + 1 + ], + [ + 2, + 17, + 1 + ], + [ + 2, + 20, + 1 + ], + [ + 2, + 21, + 1 + ], + [ + 2, + 26, + 1 + ], + [ + 2, + 27, + 1 + ], + [ + 2, + 28, + 1 + ], + [ + 2, + 29, + 1 + ], + [ + 2, + 31, + 1 + ], + [ + 2, + 32, + 1 + ], + [ + 2, + 34, + 1 + ], + [ + 2, + 37, + 1 + ], + [ + 2, + 38, + 1 + ], + [ + 2, + 39, + 1 + ], + [ + 2, + 42, + 1 + ], + [ + 2, + 43, + 1 + ], + [ + 2, + 46, + 1 + ], + [ + 2, + 47, + 1 + ], + [ + 2, + 49, + 1 + ], + [ + 2, + 52, + 1 + ], + [ + 2, + 53, + 1 + ], + [ + 2, + 54, + 1 + ], + [ + 2, + 62, + 1 + ], + [ + 2, + 63, + 1 + ], + [ + 2, + 64, + 1 + ], + [ + 2, + 65, + 1 + ], + [ + 2, + 67, + 1 + ], + [ + 2, + 68, + 1 + ], + [ + 2, + 71, + 1 + ], + [ + 2, + 72, + 1 + ], + [ + 2, + 75, + 1 + ], + [ + 2, + 76, + 1 + ], + [ + 2, + 79, + 1 + ], + [ + 2, + 80, + 1 + ], + [ + 2, + 81, + 1 + ], + [ + 2, + 82, + 1 + ], + [ + 2, + 83, + 1 + ], + [ + 2, + 84, + 1 + ], + [ + 2, + 85, + 1 + ], + [ + 2, + 86, + 1 + ], + [ + 2, + 87, + 1 + ], + [ + 2, + 88, + 1 + ], + [ + 2, + 91, + 1 + ], + [ + 2, + 92, + 1 + ], + [ + 2, + 95, + 1 + ], + [ + 2, + 96, + 1 + ], + [ + 2, + 97, + 1 + ], + [ + 2, + 100, + 1 + ], + [ + 2, + 101, + 1 + ], + [ + 2, + 103, + 1 + ], + [ + 2, + 104, + 1 + ], + [ + 2, + 107, + 1 + ], + [ + 2, + 108, + 1 + ], + [ + 4, + 5, + 1 + ], + [ + 4, + 6, + 1 + ], + [ + 4, + 7, + 1 + ], + [ + 4, + 11, + 1 + ], + [ + 4, + 12, + 1 + ], + [ + 4, + 13, + 1 + ], + [ + 4, + 18, + 1 + ], + [ + 4, + 19, + 1 + ], + [ + 4, + 20, + 1 + ], + [ + 4, + 21, + 1 + ], + [ + 4, + 26, + 1 + ], + [ + 4, + 27, + 1 + ], + [ + 4, + 28, + 1 + ], + [ + 4, + 29, + 1 + ], + [ + 4, + 34, + 1 + ], + [ + 4, + 35, + 1 + ], + [ + 4, + 36, + 1 + ], + [ + 4, + 37, + 1 + ], + [ + 4, + 42, + 1 + ], + [ + 4, + 43, + 1 + ], + [ + 4, + 44, + 1 + ], + [ + 4, + 45, + 1 + ], + [ + 4, + 49, + 1 + ], + [ + 4, + 50, + 1 + ], + [ + 4, + 51, + 1 + ], + [ + 4, + 52, + 1 + ], + [ + 4, + 53, + 1 + ], + [ + 4, + 54, + 1 + ], + [ + 4, + 55, + 1 + ], + [ + 4, + 56, + 1 + ], + [ + 4, + 57, + 1 + ], + [ + 4, + 58, + 1 + ], + [ + 4, + 60, + 1 + ], + [ + 4, + 62, + 1 + ], + [ + 4, + 65, + 1 + ], + [ + 4, + 66, + 1 + ], + [ + 4, + 67, + 1 + ], + [ + 4, + 68, + 1 + ], + [ + 4, + 73, + 1 + ], + [ + 4, + 74, + 1 + ], + [ + 4, + 75, + 1 + ], + [ + 4, + 76, + 1 + ], + [ + 4, + 81, + 1 + ], + [ + 4, + 82, + 1 + ], + [ + 4, + 83, + 1 + ], + [ + 4, + 88, + 1 + ], + [ + 4, + 89, + 1 + ], + [ + 4, + 90, + 1 + ], + [ + 4, + 91, + 1 + ], + [ + 4, + 96, + 1 + ], + [ + 4, + 97, + 1 + ], + [ + 4, + 98, + 1 + ], + [ + 4, + 99, + 1 + ], + [ + 4, + 103, + 1 + ], + [ + 4, + 104, + 1 + ], + [ + 4, + 105, + 1 + ], + [ + 4, + 106, + 1 + ], + [ + 8, + 10, + 1 + ], + [ + 8, + 12, + 1 + ], + [ + 8, + 13, + 1 + ], + [ + 8, + 15, + 1 + ], + [ + 8, + 16, + 1 + ], + [ + 8, + 18, + 1 + ], + [ + 8, + 21, + 1 + ], + [ + 8, + 23, + 1 + ], + [ + 8, + 24, + 1 + ], + [ + 8, + 26, + 1 + ], + [ + 8, + 29, + 1 + ], + [ + 8, + 31, + 1 + ], + [ + 8, + 32, + 1 + ], + [ + 8, + 34, + 1 + ], + [ + 8, + 37, + 1 + ], + [ + 8, + 39, + 1 + ], + [ + 8, + 40, + 1 + ], + [ + 8, + 42, + 1 + ], + [ + 8, + 45, + 1 + ], + [ + 8, + 46, + 1 + ], + [ + 8, + 50, + 1 + ], + [ + 8, + 54, + 1 + ], + [ + 8, + 56, + 1 + ], + [ + 8, + 57, + 1 + ], + [ + 8, + 60, + 1 + ], + [ + 8, + 62, + 1 + ], + [ + 8, + 65, + 1 + ], + [ + 8, + 66, + 1 + ], + [ + 8, + 67, + 1 + ], + [ + 8, + 69, + 1 + ], + [ + 8, + 72, + 1 + ], + [ + 8, + 73, + 1 + ], + [ + 8, + 76, + 1 + ], + [ + 8, + 78, + 1 + ], + [ + 8, + 79, + 1 + ], + [ + 8, + 81, + 1 + ], + [ + 8, + 83, + 1 + ], + [ + 8, + 85, + 1 + ], + [ + 8, + 86, + 1 + ], + [ + 8, + 88, + 1 + ], + [ + 8, + 91, + 1 + ], + [ + 8, + 93, + 1 + ], + [ + 8, + 94, + 1 + ], + [ + 8, + 96, + 1 + ], + [ + 8, + 99, + 1 + ], + [ + 8, + 101, + 1 + ], + [ + 8, + 102, + 1 + ], + [ + 8, + 104, + 1 + ], + [ + 8, + 105, + 1 + ], + [ + 8, + 107, + 1 + ], + [ + 8, + 110, + 1 + ], + [ + 9, + 11, + 1 + ], + [ + 9, + 15, + 1 + ], + [ + 9, + 16, + 1 + ], + [ + 9, + 18, + 1 + ], + [ + 9, + 21, + 1 + ], + [ + 9, + 22, + 1 + ], + [ + 9, + 25, + 1 + ], + [ + 9, + 27, + 1 + ], + [ + 9, + 28, + 1 + ], + [ + 9, + 31, + 1 + ], + [ + 9, + 32, + 1 + ], + [ + 9, + 34, + 1 + ], + [ + 9, + 37, + 1 + ], + [ + 9, + 38, + 1 + ], + [ + 9, + 41, + 1 + ], + [ + 9, + 43, + 1 + ], + [ + 9, + 44, + 1 + ], + [ + 9, + 46, + 1 + ], + [ + 9, + 50, + 1 + ], + [ + 9, + 52, + 1 + ], + [ + 9, + 53, + 1 + ], + [ + 9, + 55, + 1 + ], + [ + 9, + 58, + 1 + ], + [ + 9, + 60, + 1 + ], + [ + 9, + 62, + 1 + ], + [ + 9, + 65, + 1 + ], + [ + 9, + 68, + 1 + ], + [ + 9, + 70, + 1 + ], + [ + 9, + 71, + 1 + ], + [ + 9, + 73, + 1 + ], + [ + 9, + 76, + 1 + ], + [ + 9, + 78, + 1 + ], + [ + 9, + 79, + 1 + ], + [ + 9, + 82, + 1 + ], + [ + 9, + 84, + 1 + ], + [ + 9, + 87, + 1 + ], + [ + 9, + 88, + 1 + ], + [ + 9, + 91, + 1 + ], + [ + 9, + 93, + 1 + ], + [ + 9, + 94, + 1 + ], + [ + 9, + 97, + 1 + ], + [ + 9, + 98, + 1 + ], + [ + 9, + 100, + 1 + ], + [ + 9, + 104, + 1 + ], + [ + 9, + 105, + 1 + ], + [ + 9, + 107, + 1 + ], + [ + 9, + 110, + 1 + ], + [ + 14, + 15, + 1 + ], + [ + 14, + 16, + 1 + ], + [ + 14, + 17, + 1 + ], + [ + 14, + 18, + 1 + ], + [ + 14, + 19, + 1 + ], + [ + 14, + 20, + 1 + ], + [ + 14, + 21, + 1 + ], + [ + 14, + 22, + 1 + ], + [ + 14, + 23, + 1 + ], + [ + 14, + 24, + 1 + ], + [ + 14, + 25, + 1 + ], + [ + 14, + 26, + 1 + ], + [ + 14, + 27, + 1 + ], + [ + 14, + 28, + 1 + ], + [ + 14, + 29, + 1 + ], + [ + 14, + 46, + 1 + ], + [ + 14, + 47, + 1 + ], + [ + 14, + 48, + 1 + ], + [ + 14, + 49, + 1 + ], + [ + 14, + 50, + 1 + ], + [ + 14, + 51, + 1 + ], + [ + 14, + 52, + 1 + ], + [ + 14, + 53, + 1 + ], + [ + 14, + 54, + 1 + ], + [ + 14, + 55, + 1 + ], + [ + 14, + 56, + 1 + ], + [ + 14, + 57, + 1 + ], + [ + 14, + 58, + 1 + ], + [ + 14, + 73, + 1 + ], + [ + 14, + 74, + 1 + ], + [ + 14, + 75, + 1 + ], + [ + 14, + 76, + 1 + ], + [ + 14, + 77, + 1 + ], + [ + 14, + 78, + 1 + ], + [ + 14, + 79, + 1 + ], + [ + 14, + 80, + 1 + ], + [ + 14, + 81, + 1 + ], + [ + 14, + 82, + 1 + ], + [ + 14, + 83, + 1 + ], + [ + 14, + 84, + 1 + ], + [ + 14, + 85, + 1 + ], + [ + 14, + 86, + 1 + ], + [ + 14, + 87, + 1 + ], + [ + 14, + 103, + 1 + ], + [ + 14, + 104, + 1 + ], + [ + 14, + 105, + 1 + ], + [ + 14, + 106, + 1 + ], + [ + 14, + 107, + 1 + ], + [ + 14, + 108, + 1 + ], + [ + 14, + 109, + 1 + ], + [ + 14, + 110, + 1 + ], + [ + 30, + 31, + 1 + ], + [ + 30, + 32, + 1 + ], + [ + 30, + 33, + 1 + ], + [ + 30, + 34, + 1 + ], + [ + 30, + 35, + 1 + ], + [ + 30, + 36, + 1 + ], + [ + 30, + 37, + 1 + ], + [ + 30, + 38, + 1 + ], + [ + 30, + 39, + 1 + ], + [ + 30, + 40, + 1 + ], + [ + 30, + 41, + 1 + ], + [ + 30, + 42, + 1 + ], + [ + 30, + 43, + 1 + ], + [ + 30, + 44, + 1 + ], + [ + 30, + 45, + 1 + ], + [ + 30, + 46, + 1 + ], + [ + 30, + 47, + 1 + ], + [ + 30, + 48, + 1 + ], + [ + 30, + 49, + 1 + ], + [ + 30, + 50, + 1 + ], + [ + 30, + 51, + 1 + ], + [ + 30, + 52, + 1 + ], + [ + 30, + 53, + 1 + ], + [ + 30, + 54, + 1 + ], + [ + 30, + 55, + 1 + ], + [ + 30, + 56, + 1 + ], + [ + 30, + 57, + 1 + ], + [ + 30, + 58, + 1 + ], + [ + 30, + 88, + 1 + ], + [ + 30, + 89, + 1 + ], + [ + 30, + 90, + 1 + ], + [ + 30, + 91, + 1 + ], + [ + 30, + 92, + 1 + ], + [ + 30, + 93, + 1 + ], + [ + 30, + 94, + 1 + ], + [ + 30, + 95, + 1 + ], + [ + 30, + 96, + 1 + ], + [ + 30, + 97, + 1 + ], + [ + 30, + 98, + 1 + ], + [ + 30, + 99, + 1 + ], + [ + 30, + 100, + 1 + ], + [ + 30, + 101, + 1 + ], + [ + 30, + 102, + 1 + ], + [ + 30, + 103, + 1 + ], + [ + 30, + 104, + 1 + ], + [ + 30, + 105, + 1 + ], + [ + 30, + 106, + 1 + ], + [ + 30, + 107, + 1 + ], + [ + 30, + 108, + 1 + ], + [ + 30, + 109, + 1 + ], + [ + 30, + 110, + 1 + ], + [ + 59, + 60, + 1 + ], + [ + 59, + 61, + 1 + ], + [ + 59, + 62, + 1 + ], + [ + 59, + 63, + 1 + ], + [ + 59, + 64, + 1 + ], + [ + 59, + 65, + 1 + ], + [ + 59, + 66, + 1 + ], + [ + 59, + 67, + 1 + ], + [ + 59, + 68, + 1 + ], + [ + 59, + 69, + 1 + ], + [ + 59, + 70, + 1 + ], + [ + 59, + 71, + 1 + ], + [ + 59, + 72, + 1 + ], + [ + 59, + 73, + 1 + ], + [ + 59, + 74, + 1 + ], + [ + 59, + 75, + 1 + ], + [ + 59, + 76, + 1 + ], + [ + 59, + 77, + 1 + ], + [ + 59, + 78, + 1 + ], + [ + 59, + 79, + 1 + ], + [ + 59, + 80, + 1 + ], + [ + 59, + 81, + 1 + ], + [ + 59, + 82, + 1 + ], + [ + 59, + 83, + 1 + ], + [ + 59, + 84, + 1 + ], + [ + 59, + 85, + 1 + ], + [ + 59, + 86, + 1 + ], + [ + 59, + 87, + 1 + ], + [ + 59, + 88, + 1 + ], + [ + 59, + 89, + 1 + ], + [ + 59, + 90, + 1 + ], + [ + 59, + 91, + 1 + ], + [ + 59, + 92, + 1 + ], + [ + 59, + 93, + 1 + ], + [ + 59, + 94, + 1 + ], + [ + 59, + 95, + 1 + ], + [ + 59, + 96, + 1 + ], + [ + 59, + 97, + 1 + ], + [ + 59, + 98, + 1 + ], + [ + 59, + 99, + 1 + ], + [ + 59, + 100, + 1 + ], + [ + 59, + 101, + 1 + ], + [ + 59, + 102, + 1 + ], + [ + 59, + 103, + 1 + ], + [ + 59, + 104, + 1 + ], + [ + 59, + 105, + 1 + ], + [ + 59, + 106, + 1 + ], + [ + 59, + 107, + 1 + ], + [ + 59, + 108, + 1 + ], + [ + 59, + 109, + 1 + ], + [ + 59, + 110, + 1 + ], + [ + 8, + 0, + -1 + ], + [ + 1, + 4, + -1 + ], + [ + 4, + 1, + -1 + ], + [ + 1, + 4, + -1 + ], + [ + 8, + 1, + -1 + ], + [ + 30, + 1, + -1 + ], + [ + 8, + 2, + -1 + ], + [ + 14, + 2, + -1 + ], + [ + 2, + 4, + -1 + ], + [ + 9, + 4, + -1 + ], + [ + 30, + 4, + -1 + ], + [ + 59, + 4, + -1 + ], + [ + 8, + 9, + -1 + ], + [ + 9, + 8, + -1 + ], + [ + 8, + 9, + -1 + ], + [ + 0, + 8, + -1 + ], + [ + 1, + 8, + -1 + ], + [ + 4, + 8, + -1 + ], + [ + 14, + 8, + -1 + ], + [ + 9, + 30, + -1 + ], + [ + 30, + 9, + -1 + ], + [ + 9, + 30, + -1 + ], + [ + 1, + 9, + -1 + ], + [ + 2, + 14, + -1 + ], + [ + 8, + 14, + -1 + ], + [ + 59, + 14, + -1 + ], + [ + 30, + 59, + -1 + ], + [ + 59, + 30, + -1 + ], + [ + 30, + 59, + -1 + ], + [ + 2, + 30, + -1 + ], + [ + 4, + 30, + -1 + ], + [ + 9, + 30, + -1 + ], + [ + 14, + 30, + -1 + ], + [ + 14, + 59, + -1 + ], + [ + 30, + 59, + -1 + ], + [ + 110, + 59, + -1 + ], + [ + 110, + 30, + -1 + ], + [ + 110, + 14, + -1 + ], + [ + 110, + 9, + -1 + ], + [ + 110, + 8, + -1 + ], + [ + 110, + 4, + -1 + ], + [ + 110, + 2, + -1 + ], + [ + 110, + 1, + -1 + ], + [ + 109, + 59, + -1 + ], + [ + 109, + 30, + -1 + ], + [ + 109, + 9, + -1 + ], + [ + 109, + 8, + -1 + ], + [ + 109, + 4, + -1 + ], + [ + 109, + 2, + -1 + ], + [ + 109, + 1, + -1 + ], + [ + 108, + 59, + -1 + ], + [ + 108, + 14, + -1 + ], + [ + 108, + 9, + -1 + ], + [ + 108, + 8, + -1 + ], + [ + 108, + 4, + -1 + ], + [ + 108, + 2, + -1 + ], + [ + 108, + 1, + -1 + ], + [ + 107, + 59, + -1 + ], + [ + 107, + 9, + -1 + ], + [ + 107, + 8, + -1 + ], + [ + 107, + 4, + -1 + ], + [ + 107, + 2, + -1 + ], + [ + 107, + 1, + -1 + ], + [ + 106, + 30, + -1 + ], + [ + 106, + 14, + -1 + ], + [ + 106, + 9, + -1 + ], + [ + 106, + 8, + -1 + ], + [ + 106, + 4, + -1 + ], + [ + 106, + 2, + -1 + ], + [ + 106, + 1, + -1 + ], + [ + 105, + 30, + -1 + ], + [ + 105, + 9, + -1 + ], + [ + 105, + 8, + -1 + ], + [ + 105, + 4, + -1 + ], + [ + 105, + 2, + -1 + ], + [ + 105, + 1, + -1 + ], + [ + 104, + 14, + -1 + ], + [ + 104, + 9, + -1 + ], + [ + 104, + 8, + -1 + ], + [ + 104, + 4, + -1 + ], + [ + 104, + 2, + -1 + ], + [ + 104, + 1, + -1 + ], + [ + 103, + 9, + -1 + ], + [ + 103, + 8, + -1 + ], + [ + 103, + 4, + -1 + ], + [ + 103, + 2, + -1 + ], + [ + 103, + 1, + -1 + ], + [ + 102, + 59, + -1 + ], + [ + 102, + 30, + -1 + ], + [ + 102, + 14, + -1 + ], + [ + 102, + 9, + -1 + ], + [ + 102, + 4, + -1 + ], + [ + 102, + 2, + -1 + ], + [ + 102, + 0, + -1 + ], + [ + 101, + 59, + -1 + ], + [ + 101, + 14, + -1 + ], + [ + 101, + 8, + -1 + ], + [ + 101, + 4, + -1 + ], + [ + 101, + 2, + -1 + ], + [ + 101, + 0, + -1 + ], + [ + 100, + 59, + -1 + ], + [ + 100, + 14, + -1 + ], + [ + 100, + 9, + -1 + ], + [ + 100, + 4, + -1 + ], + [ + 100, + 2, + -1 + ], + [ + 100, + 0, + -1 + ], + [ + 99, + 30, + -1 + ], + [ + 99, + 14, + -1 + ], + [ + 99, + 8, + -1 + ], + [ + 99, + 4, + -1 + ], + [ + 99, + 2, + -1 + ], + [ + 99, + 0, + -1 + ], + [ + 98, + 30, + -1 + ], + [ + 98, + 14, + -1 + ], + [ + 98, + 9, + -1 + ], + [ + 98, + 4, + -1 + ], + [ + 98, + 2, + -1 + ], + [ + 98, + 0, + -1 + ], + [ + 97, + 14, + -1 + ], + [ + 97, + 8, + -1 + ], + [ + 97, + 4, + -1 + ], + [ + 97, + 2, + -1 + ], + [ + 97, + 0, + -1 + ], + [ + 96, + 14, + -1 + ], + [ + 96, + 9, + -1 + ], + [ + 96, + 4, + -1 + ], + [ + 96, + 2, + -1 + ], + [ + 96, + 0, + -1 + ], + [ + 95, + 59, + -1 + ], + [ + 95, + 14, + -1 + ], + [ + 95, + 9, + -1 + ], + [ + 95, + 8, + -1 + ], + [ + 95, + 1, + -1 + ], + [ + 95, + 0, + -1 + ], + [ + 94, + 59, + -1 + ], + [ + 94, + 30, + -1 + ], + [ + 94, + 14, + -1 + ], + [ + 94, + 9, + -1 + ], + [ + 94, + 8, + -1 + ], + [ + 94, + 1, + -1 + ], + [ + 94, + 0, + -1 + ], + [ + 93, + 59, + -1 + ], + [ + 93, + 30, + -1 + ], + [ + 93, + 1, + -1 + ], + [ + 93, + 0, + -1 + ], + [ + 92, + 59, + -1 + ], + [ + 92, + 1, + -1 + ], + [ + 92, + 0, + -1 + ], + [ + 91, + 14, + -1 + ], + [ + 91, + 9, + -1 + ], + [ + 91, + 8, + -1 + ], + [ + 91, + 1, + -1 + ], + [ + 91, + 0, + -1 + ], + [ + 90, + 30, + -1 + ], + [ + 90, + 14, + -1 + ], + [ + 90, + 9, + -1 + ], + [ + 90, + 8, + -1 + ], + [ + 90, + 1, + -1 + ], + [ + 90, + 0, + -1 + ], + [ + 89, + 30, + -1 + ], + [ + 89, + 1, + -1 + ], + [ + 89, + 0, + -1 + ], + [ + 88, + 1, + -1 + ], + [ + 88, + 0, + -1 + ], + [ + 87, + 59, + -1 + ], + [ + 87, + 30, + -1 + ], + [ + 87, + 14, + -1 + ], + [ + 87, + 8, + -1 + ], + [ + 87, + 4, + -1 + ], + [ + 87, + 1, + -1 + ], + [ + 87, + 0, + -1 + ], + [ + 86, + 59, + -1 + ], + [ + 86, + 30, + -1 + ], + [ + 86, + 14, + -1 + ], + [ + 86, + 9, + -1 + ], + [ + 86, + 4, + -1 + ], + [ + 86, + 1, + -1 + ], + [ + 86, + 0, + -1 + ], + [ + 85, + 59, + -1 + ], + [ + 85, + 30, + -1 + ], + [ + 85, + 8, + -1 + ], + [ + 85, + 4, + -1 + ], + [ + 85, + 1, + -1 + ], + [ + 85, + 0, + -1 + ], + [ + 84, + 59, + -1 + ], + [ + 84, + 30, + -1 + ], + [ + 84, + 9, + -1 + ], + [ + 84, + 4, + -1 + ], + [ + 84, + 1, + -1 + ], + [ + 84, + 0, + -1 + ], + [ + 83, + 30, + -1 + ], + [ + 83, + 14, + -1 + ], + [ + 83, + 8, + -1 + ], + [ + 83, + 4, + -1 + ], + [ + 83, + 1, + -1 + ], + [ + 83, + 0, + -1 + ], + [ + 82, + 30, + -1 + ], + [ + 82, + 14, + -1 + ], + [ + 82, + 9, + -1 + ], + [ + 82, + 4, + -1 + ], + [ + 82, + 1, + -1 + ], + [ + 82, + 0, + -1 + ], + [ + 81, + 30, + -1 + ], + [ + 81, + 9, + -1 + ], + [ + 81, + 4, + -1 + ], + [ + 81, + 1, + -1 + ], + [ + 81, + 0, + -1 + ], + [ + 80, + 59, + -1 + ], + [ + 80, + 30, + -1 + ], + [ + 80, + 9, + -1 + ], + [ + 80, + 8, + -1 + ], + [ + 80, + 2, + -1 + ], + [ + 80, + 0, + -1 + ], + [ + 79, + 59, + -1 + ], + [ + 79, + 30, + -1 + ], + [ + 79, + 14, + -1 + ], + [ + 79, + 9, + -1 + ], + [ + 79, + 8, + -1 + ], + [ + 79, + 2, + -1 + ], + [ + 79, + 0, + -1 + ], + [ + 78, + 59, + -1 + ], + [ + 78, + 14, + -1 + ], + [ + 78, + 2, + -1 + ], + [ + 78, + 0, + -1 + ], + [ + 77, + 59, + -1 + ], + [ + 77, + 2, + -1 + ], + [ + 77, + 0, + -1 + ], + [ + 76, + 30, + -1 + ], + [ + 76, + 9, + -1 + ], + [ + 76, + 8, + -1 + ], + [ + 76, + 2, + -1 + ], + [ + 76, + 0, + -1 + ], + [ + 75, + 30, + -1 + ], + [ + 75, + 14, + -1 + ], + [ + 75, + 9, + -1 + ], + [ + 75, + 8, + -1 + ], + [ + 75, + 2, + -1 + ], + [ + 75, + 0, + -1 + ], + [ + 74, + 14, + -1 + ], + [ + 74, + 2, + -1 + ], + [ + 74, + 0, + -1 + ], + [ + 73, + 2, + -1 + ], + [ + 73, + 0, + -1 + ], + [ + 72, + 59, + -1 + ], + [ + 72, + 30, + -1 + ], + [ + 72, + 14, + -1 + ], + [ + 72, + 9, + -1 + ], + [ + 72, + 2, + -1 + ], + [ + 72, + 1, + -1 + ], + [ + 71, + 59, + -1 + ], + [ + 71, + 30, + -1 + ], + [ + 71, + 14, + -1 + ], + [ + 71, + 8, + -1 + ], + [ + 71, + 2, + -1 + ], + [ + 71, + 1, + -1 + ], + [ + 70, + 59, + -1 + ], + [ + 70, + 8, + -1 + ], + [ + 70, + 2, + -1 + ], + [ + 70, + 1, + -1 + ], + [ + 69, + 59, + -1 + ], + [ + 69, + 9, + -1 + ], + [ + 69, + 2, + -1 + ], + [ + 69, + 1, + -1 + ], + [ + 68, + 30, + -1 + ], + [ + 68, + 14, + -1 + ], + [ + 68, + 9, + -1 + ], + [ + 68, + 2, + -1 + ], + [ + 68, + 1, + -1 + ], + [ + 67, + 30, + -1 + ], + [ + 67, + 14, + -1 + ], + [ + 67, + 8, + -1 + ], + [ + 67, + 2, + -1 + ], + [ + 67, + 1, + -1 + ], + [ + 66, + 8, + -1 + ], + [ + 66, + 2, + -1 + ], + [ + 66, + 1, + -1 + ], + [ + 65, + 30, + -1 + ], + [ + 65, + 14, + -1 + ], + [ + 65, + 4, + -1 + ], + [ + 64, + 59, + -1 + ], + [ + 64, + 30, + -1 + ], + [ + 64, + 14, + -1 + ], + [ + 64, + 4, + -1 + ], + [ + 63, + 59, + -1 + ], + [ + 63, + 30, + -1 + ], + [ + 63, + 9, + -1 + ], + [ + 63, + 8, + -1 + ], + [ + 63, + 4, + -1 + ], + [ + 62, + 30, + -1 + ], + [ + 62, + 9, + -1 + ], + [ + 62, + 8, + -1 + ], + [ + 62, + 4, + -1 + ], + [ + 61, + 59, + -1 + ], + [ + 61, + 14, + -1 + ], + [ + 61, + 9, + -1 + ], + [ + 61, + 8, + -1 + ], + [ + 61, + 4, + -1 + ], + [ + 60, + 4, + -1 + ], + [ + 58, + 59, + -1 + ], + [ + 58, + 30, + -1 + ], + [ + 58, + 14, + -1 + ], + [ + 58, + 8, + -1 + ], + [ + 58, + 2, + -1 + ], + [ + 58, + 1, + -1 + ], + [ + 58, + 0, + -1 + ], + [ + 57, + 59, + -1 + ], + [ + 57, + 30, + -1 + ], + [ + 57, + 14, + -1 + ], + [ + 57, + 9, + -1 + ], + [ + 57, + 2, + -1 + ], + [ + 57, + 1, + -1 + ], + [ + 57, + 0, + -1 + ], + [ + 56, + 59, + -1 + ], + [ + 56, + 30, + -1 + ], + [ + 56, + 8, + -1 + ], + [ + 56, + 2, + -1 + ], + [ + 56, + 1, + -1 + ], + [ + 56, + 0, + -1 + ], + [ + 55, + 59, + -1 + ], + [ + 55, + 30, + -1 + ], + [ + 55, + 9, + -1 + ], + [ + 55, + 2, + -1 + ], + [ + 55, + 1, + -1 + ], + [ + 55, + 0, + -1 + ], + [ + 54, + 59, + -1 + ], + [ + 54, + 14, + -1 + ], + [ + 54, + 8, + -1 + ], + [ + 54, + 2, + -1 + ], + [ + 54, + 1, + -1 + ], + [ + 54, + 0, + -1 + ], + [ + 53, + 59, + -1 + ], + [ + 53, + 14, + -1 + ], + [ + 53, + 9, + -1 + ], + [ + 53, + 2, + -1 + ], + [ + 53, + 1, + -1 + ], + [ + 53, + 0, + -1 + ], + [ + 52, + 59, + -1 + ], + [ + 52, + 8, + -1 + ], + [ + 52, + 2, + -1 + ], + [ + 52, + 1, + -1 + ], + [ + 52, + 0, + -1 + ], + [ + 51, + 59, + -1 + ], + [ + 51, + 30, + -1 + ], + [ + 51, + 9, + -1 + ], + [ + 51, + 8, + -1 + ], + [ + 51, + 4, + -1 + ], + [ + 51, + 0, + -1 + ], + [ + 50, + 59, + -1 + ], + [ + 50, + 30, + -1 + ], + [ + 50, + 14, + -1 + ], + [ + 50, + 9, + -1 + ], + [ + 50, + 8, + -1 + ], + [ + 50, + 4, + -1 + ], + [ + 50, + 0, + -1 + ], + [ + 49, + 59, + -1 + ], + [ + 49, + 14, + -1 + ], + [ + 49, + 9, + -1 + ], + [ + 49, + 8, + -1 + ], + [ + 49, + 4, + -1 + ], + [ + 49, + 0, + -1 + ], + [ + 48, + 30, + -1 + ], + [ + 48, + 4, + -1 + ], + [ + 48, + 0, + -1 + ], + [ + 47, + 14, + -1 + ], + [ + 47, + 4, + -1 + ], + [ + 47, + 0, + -1 + ], + [ + 46, + 4, + -1 + ], + [ + 46, + 0, + -1 + ], + [ + 45, + 59, + -1 + ], + [ + 45, + 30, + -1 + ], + [ + 45, + 14, + -1 + ], + [ + 45, + 9, + -1 + ], + [ + 45, + 4, + -1 + ], + [ + 45, + 1, + -1 + ], + [ + 44, + 59, + -1 + ], + [ + 44, + 30, + -1 + ], + [ + 44, + 14, + -1 + ], + [ + 44, + 8, + -1 + ], + [ + 44, + 4, + -1 + ], + [ + 44, + 1, + -1 + ], + [ + 43, + 59, + -1 + ], + [ + 43, + 14, + -1 + ], + [ + 43, + 9, + -1 + ], + [ + 43, + 4, + -1 + ], + [ + 43, + 1, + -1 + ], + [ + 42, + 59, + -1 + ], + [ + 42, + 14, + -1 + ], + [ + 42, + 8, + -1 + ], + [ + 42, + 4, + -1 + ], + [ + 42, + 1, + -1 + ], + [ + 41, + 30, + -1 + ], + [ + 41, + 8, + -1 + ], + [ + 41, + 4, + -1 + ], + [ + 41, + 1, + -1 + ], + [ + 40, + 30, + -1 + ], + [ + 40, + 9, + -1 + ], + [ + 40, + 4, + -1 + ], + [ + 40, + 1, + -1 + ], + [ + 39, + 8, + -1 + ], + [ + 39, + 4, + -1 + ], + [ + 39, + 1, + -1 + ], + [ + 38, + 9, + -1 + ], + [ + 38, + 4, + -1 + ], + [ + 38, + 1, + -1 + ], + [ + 37, + 59, + -1 + ], + [ + 37, + 14, + -1 + ], + [ + 37, + 2, + -1 + ], + [ + 36, + 59, + -1 + ], + [ + 36, + 30, + -1 + ], + [ + 36, + 14, + -1 + ], + [ + 36, + 2, + -1 + ], + [ + 35, + 59, + -1 + ], + [ + 35, + 30, + -1 + ], + [ + 35, + 9, + -1 + ], + [ + 35, + 8, + -1 + ], + [ + 35, + 2, + -1 + ], + [ + 34, + 59, + -1 + ], + [ + 34, + 9, + -1 + ], + [ + 34, + 8, + -1 + ], + [ + 34, + 2, + -1 + ], + [ + 33, + 30, + -1 + ], + [ + 33, + 14, + -1 + ], + [ + 33, + 9, + -1 + ], + [ + 33, + 8, + -1 + ], + [ + 33, + 2, + -1 + ], + [ + 32, + 14, + -1 + ], + [ + 32, + 9, + -1 + ], + [ + 32, + 8, + -1 + ], + [ + 32, + 2, + -1 + ], + [ + 31, + 2, + -1 + ], + [ + 29, + 59, + -1 + ], + [ + 29, + 30, + -1 + ], + [ + 29, + 14, + -1 + ], + [ + 29, + 9, + -1 + ], + [ + 29, + 4, + -1 + ], + [ + 29, + 2, + -1 + ], + [ + 28, + 59, + -1 + ], + [ + 28, + 30, + -1 + ], + [ + 28, + 14, + -1 + ], + [ + 28, + 8, + -1 + ], + [ + 28, + 4, + -1 + ], + [ + 28, + 2, + -1 + ], + [ + 27, + 59, + -1 + ], + [ + 27, + 30, + -1 + ], + [ + 27, + 9, + -1 + ], + [ + 27, + 4, + -1 + ], + [ + 27, + 2, + -1 + ], + [ + 26, + 59, + -1 + ], + [ + 26, + 30, + -1 + ], + [ + 26, + 8, + -1 + ], + [ + 26, + 4, + -1 + ], + [ + 26, + 2, + -1 + ], + [ + 25, + 14, + -1 + ], + [ + 25, + 8, + -1 + ], + [ + 25, + 4, + -1 + ], + [ + 25, + 2, + -1 + ], + [ + 24, + 14, + -1 + ], + [ + 24, + 9, + -1 + ], + [ + 24, + 4, + -1 + ], + [ + 24, + 2, + -1 + ], + [ + 23, + 8, + -1 + ], + [ + 23, + 4, + -1 + ], + [ + 23, + 2, + -1 + ], + [ + 22, + 9, + -1 + ], + [ + 22, + 4, + -1 + ], + [ + 22, + 2, + -1 + ], + [ + 21, + 59, + -1 + ], + [ + 21, + 30, + -1 + ], + [ + 21, + 1, + -1 + ], + [ + 20, + 59, + -1 + ], + [ + 20, + 30, + -1 + ], + [ + 20, + 14, + -1 + ], + [ + 20, + 1, + -1 + ], + [ + 19, + 59, + -1 + ], + [ + 19, + 14, + -1 + ], + [ + 19, + 9, + -1 + ], + [ + 19, + 8, + -1 + ], + [ + 19, + 1, + -1 + ], + [ + 18, + 59, + -1 + ], + [ + 18, + 9, + -1 + ], + [ + 18, + 8, + -1 + ], + [ + 18, + 1, + -1 + ], + [ + 17, + 30, + -1 + ], + [ + 17, + 14, + -1 + ], + [ + 17, + 9, + -1 + ], + [ + 17, + 8, + -1 + ], + [ + 17, + 1, + -1 + ], + [ + 16, + 30, + -1 + ], + [ + 16, + 9, + -1 + ], + [ + 16, + 8, + -1 + ], + [ + 16, + 1, + -1 + ], + [ + 15, + 1, + -1 + ], + [ + 13, + 59, + -1 + ], + [ + 13, + 30, + -1 + ], + [ + 13, + 8, + -1 + ], + [ + 13, + 0, + -1 + ], + [ + 12, + 59, + -1 + ], + [ + 12, + 14, + -1 + ], + [ + 12, + 8, + -1 + ], + [ + 12, + 0, + -1 + ], + [ + 11, + 59, + -1 + ], + [ + 11, + 14, + -1 + ], + [ + 11, + 9, + -1 + ], + [ + 11, + 0, + -1 + ], + [ + 10, + 30, + -1 + ], + [ + 10, + 14, + -1 + ], + [ + 10, + 8, + -1 + ], + [ + 10, + 0, + -1 + ], + [ + 7, + 59, + -1 + ], + [ + 7, + 30, + -1 + ], + [ + 7, + 14, + -1 + ], + [ + 7, + 4, + -1 + ], + [ + 7, + 2, + -1 + ], + [ + 7, + 1, + -1 + ], + [ + 7, + 0, + -1 + ], + [ + 6, + 59, + -1 + ], + [ + 6, + 30, + -1 + ], + [ + 6, + 9, + -1 + ], + [ + 6, + 8, + -1 + ], + [ + 6, + 4, + -1 + ], + [ + 6, + 2, + -1 + ], + [ + 6, + 1, + -1 + ], + [ + 6, + 0, + -1 + ], + [ + 5, + 59, + -1 + ], + [ + 5, + 14, + -1 + ], + [ + 5, + 9, + -1 + ], + [ + 5, + 8, + -1 + ], + [ + 5, + 4, + -1 + ], + [ + 5, + 2, + -1 + ], + [ + 5, + 1, + -1 + ], + [ + 5, + 0, + -1 + ], + [ + 3, + 30, + -1 + ], + [ + 3, + 14, + -1 + ], + [ + 3, + 9, + -1 + ], + [ + 3, + 8, + -1 + ], + [ + 3, + 4, + -1 + ], + [ + 3, + 2, + -1 + ], + [ + 3, + 1, + -1 + ], + [ + 3, + 0, + -1 + ], + [ + 59, + 110, + -1 + ], + [ + 59, + 109, + -1 + ], + [ + 59, + 108, + -1 + ], + [ + 59, + 107, + -1 + ], + [ + 59, + 106, + -1 + ], + [ + 59, + 105, + -1 + ], + [ + 59, + 104, + -1 + ], + [ + 59, + 103, + -1 + ], + [ + 59, + 102, + -1 + ], + [ + 59, + 101, + -1 + ], + [ + 59, + 100, + -1 + ], + [ + 59, + 99, + -1 + ], + [ + 59, + 98, + -1 + ], + [ + 59, + 97, + -1 + ], + [ + 59, + 96, + -1 + ], + [ + 59, + 95, + -1 + ], + [ + 59, + 94, + -1 + ], + [ + 59, + 93, + -1 + ], + [ + 59, + 92, + -1 + ], + [ + 59, + 91, + -1 + ], + [ + 59, + 90, + -1 + ], + [ + 59, + 89, + -1 + ], + [ + 59, + 88, + -1 + ], + [ + 59, + 87, + -1 + ], + [ + 59, + 86, + -1 + ], + [ + 59, + 85, + -1 + ], + [ + 59, + 84, + -1 + ], + [ + 59, + 83, + -1 + ], + [ + 59, + 82, + -1 + ], + [ + 59, + 81, + -1 + ], + [ + 59, + 80, + -1 + ], + [ + 59, + 79, + -1 + ], + [ + 59, + 78, + -1 + ], + [ + 59, + 77, + -1 + ], + [ + 59, + 76, + -1 + ], + [ + 59, + 75, + -1 + ], + [ + 59, + 74, + -1 + ], + [ + 59, + 73, + -1 + ], + [ + 59, + 72, + -1 + ], + [ + 59, + 71, + -1 + ], + [ + 59, + 70, + -1 + ], + [ + 59, + 69, + -1 + ], + [ + 59, + 68, + -1 + ], + [ + 59, + 67, + -1 + ], + [ + 59, + 66, + -1 + ], + [ + 59, + 65, + -1 + ], + [ + 59, + 64, + -1 + ], + [ + 59, + 63, + -1 + ], + [ + 59, + 62, + -1 + ], + [ + 59, + 61, + -1 + ], + [ + 59, + 60, + -1 + ], + [ + 30, + 110, + -1 + ], + [ + 30, + 109, + -1 + ], + [ + 30, + 108, + -1 + ], + [ + 30, + 107, + -1 + ], + [ + 30, + 106, + -1 + ], + [ + 30, + 105, + -1 + ], + [ + 30, + 104, + -1 + ], + [ + 30, + 103, + -1 + ], + [ + 30, + 102, + -1 + ], + [ + 30, + 101, + -1 + ], + [ + 30, + 100, + -1 + ], + [ + 30, + 99, + -1 + ], + [ + 30, + 98, + -1 + ], + [ + 30, + 97, + -1 + ], + [ + 30, + 96, + -1 + ], + [ + 30, + 95, + -1 + ], + [ + 30, + 94, + -1 + ], + [ + 30, + 93, + -1 + ], + [ + 30, + 92, + -1 + ], + [ + 30, + 91, + -1 + ], + [ + 30, + 90, + -1 + ], + [ + 30, + 89, + -1 + ], + [ + 30, + 88, + -1 + ], + [ + 30, + 58, + -1 + ], + [ + 30, + 57, + -1 + ], + [ + 30, + 56, + -1 + ], + [ + 30, + 55, + -1 + ], + [ + 30, + 54, + -1 + ], + [ + 30, + 53, + -1 + ], + [ + 30, + 52, + -1 + ], + [ + 30, + 51, + -1 + ], + [ + 30, + 50, + -1 + ], + [ + 30, + 49, + -1 + ], + [ + 30, + 48, + -1 + ], + [ + 30, + 47, + -1 + ], + [ + 30, + 46, + -1 + ], + [ + 30, + 45, + -1 + ], + [ + 30, + 44, + -1 + ], + [ + 30, + 43, + -1 + ], + [ + 30, + 42, + -1 + ], + [ + 30, + 41, + -1 + ], + [ + 30, + 40, + -1 + ], + [ + 30, + 39, + -1 + ], + [ + 30, + 38, + -1 + ], + [ + 30, + 37, + -1 + ], + [ + 30, + 36, + -1 + ], + [ + 30, + 35, + -1 + ], + [ + 30, + 34, + -1 + ], + [ + 30, + 33, + -1 + ], + [ + 30, + 32, + -1 + ], + [ + 30, + 31, + -1 + ], + [ + 14, + 110, + -1 + ], + [ + 14, + 109, + -1 + ], + [ + 14, + 108, + -1 + ], + [ + 14, + 107, + -1 + ], + [ + 14, + 106, + -1 + ], + [ + 14, + 105, + -1 + ], + [ + 14, + 104, + -1 + ], + [ + 14, + 103, + -1 + ], + [ + 14, + 87, + -1 + ], + [ + 14, + 86, + -1 + ], + [ + 14, + 85, + -1 + ], + [ + 14, + 84, + -1 + ], + [ + 14, + 83, + -1 + ], + [ + 14, + 82, + -1 + ], + [ + 14, + 81, + -1 + ], + [ + 14, + 80, + -1 + ], + [ + 14, + 79, + -1 + ], + [ + 14, + 78, + -1 + ], + [ + 14, + 77, + -1 + ], + [ + 14, + 76, + -1 + ], + [ + 14, + 75, + -1 + ], + [ + 14, + 74, + -1 + ], + [ + 14, + 73, + -1 + ], + [ + 14, + 58, + -1 + ], + [ + 14, + 57, + -1 + ], + [ + 14, + 56, + -1 + ], + [ + 14, + 55, + -1 + ], + [ + 14, + 54, + -1 + ], + [ + 14, + 53, + -1 + ], + [ + 14, + 52, + -1 + ], + [ + 14, + 51, + -1 + ], + [ + 14, + 50, + -1 + ], + [ + 14, + 49, + -1 + ], + [ + 14, + 48, + -1 + ], + [ + 14, + 47, + -1 + ], + [ + 14, + 46, + -1 + ], + [ + 14, + 29, + -1 + ], + [ + 14, + 28, + -1 + ], + [ + 14, + 27, + -1 + ], + [ + 14, + 26, + -1 + ], + [ + 14, + 25, + -1 + ], + [ + 14, + 24, + -1 + ], + [ + 14, + 23, + -1 + ], + [ + 14, + 22, + -1 + ], + [ + 14, + 21, + -1 + ], + [ + 14, + 20, + -1 + ], + [ + 14, + 19, + -1 + ], + [ + 14, + 18, + -1 + ], + [ + 14, + 17, + -1 + ], + [ + 14, + 16, + -1 + ], + [ + 14, + 15, + -1 + ], + [ + 9, + 110, + -1 + ], + [ + 9, + 107, + -1 + ], + [ + 9, + 105, + -1 + ], + [ + 9, + 104, + -1 + ], + [ + 9, + 100, + -1 + ], + [ + 9, + 98, + -1 + ], + [ + 9, + 97, + -1 + ], + [ + 9, + 94, + -1 + ], + [ + 9, + 93, + -1 + ], + [ + 9, + 91, + -1 + ], + [ + 9, + 88, + -1 + ], + [ + 9, + 87, + -1 + ], + [ + 9, + 84, + -1 + ], + [ + 9, + 82, + -1 + ], + [ + 9, + 79, + -1 + ], + [ + 9, + 78, + -1 + ], + [ + 9, + 76, + -1 + ], + [ + 9, + 73, + -1 + ], + [ + 9, + 71, + -1 + ], + [ + 9, + 70, + -1 + ], + [ + 9, + 68, + -1 + ], + [ + 9, + 65, + -1 + ], + [ + 9, + 62, + -1 + ], + [ + 9, + 60, + -1 + ], + [ + 9, + 58, + -1 + ], + [ + 9, + 55, + -1 + ], + [ + 9, + 53, + -1 + ], + [ + 9, + 52, + -1 + ], + [ + 9, + 50, + -1 + ], + [ + 9, + 46, + -1 + ], + [ + 9, + 44, + -1 + ], + [ + 9, + 43, + -1 + ], + [ + 9, + 41, + -1 + ], + [ + 9, + 38, + -1 + ], + [ + 9, + 37, + -1 + ], + [ + 9, + 34, + -1 + ], + [ + 9, + 32, + -1 + ], + [ + 9, + 31, + -1 + ], + [ + 9, + 28, + -1 + ], + [ + 9, + 27, + -1 + ], + [ + 9, + 25, + -1 + ], + [ + 9, + 22, + -1 + ], + [ + 9, + 21, + -1 + ], + [ + 9, + 18, + -1 + ], + [ + 9, + 16, + -1 + ], + [ + 9, + 15, + -1 + ], + [ + 9, + 11, + -1 + ], + [ + 8, + 110, + -1 + ], + [ + 8, + 107, + -1 + ], + [ + 8, + 105, + -1 + ], + [ + 8, + 104, + -1 + ], + [ + 8, + 102, + -1 + ], + [ + 8, + 101, + -1 + ], + [ + 8, + 99, + -1 + ], + [ + 8, + 96, + -1 + ], + [ + 8, + 94, + -1 + ], + [ + 8, + 93, + -1 + ], + [ + 8, + 91, + -1 + ], + [ + 8, + 88, + -1 + ], + [ + 8, + 86, + -1 + ], + [ + 8, + 85, + -1 + ], + [ + 8, + 83, + -1 + ], + [ + 8, + 81, + -1 + ], + [ + 8, + 79, + -1 + ], + [ + 8, + 78, + -1 + ], + [ + 8, + 76, + -1 + ], + [ + 8, + 73, + -1 + ], + [ + 8, + 72, + -1 + ], + [ + 8, + 69, + -1 + ], + [ + 8, + 67, + -1 + ], + [ + 8, + 66, + -1 + ], + [ + 8, + 65, + -1 + ], + [ + 8, + 62, + -1 + ], + [ + 8, + 60, + -1 + ], + [ + 8, + 57, + -1 + ], + [ + 8, + 56, + -1 + ], + [ + 8, + 54, + -1 + ], + [ + 8, + 50, + -1 + ], + [ + 8, + 46, + -1 + ], + [ + 8, + 45, + -1 + ], + [ + 8, + 42, + -1 + ], + [ + 8, + 40, + -1 + ], + [ + 8, + 39, + -1 + ], + [ + 8, + 37, + -1 + ], + [ + 8, + 34, + -1 + ], + [ + 8, + 32, + -1 + ], + [ + 8, + 31, + -1 + ], + [ + 8, + 29, + -1 + ], + [ + 8, + 26, + -1 + ], + [ + 8, + 24, + -1 + ], + [ + 8, + 23, + -1 + ], + [ + 8, + 21, + -1 + ], + [ + 8, + 18, + -1 + ], + [ + 8, + 16, + -1 + ], + [ + 8, + 15, + -1 + ], + [ + 8, + 13, + -1 + ], + [ + 8, + 12, + -1 + ], + [ + 8, + 10, + -1 + ], + [ + 4, + 106, + -1 + ], + [ + 4, + 105, + -1 + ], + [ + 4, + 104, + -1 + ], + [ + 4, + 103, + -1 + ], + [ + 4, + 99, + -1 + ], + [ + 4, + 98, + -1 + ], + [ + 4, + 97, + -1 + ], + [ + 4, + 96, + -1 + ], + [ + 4, + 91, + -1 + ], + [ + 4, + 90, + -1 + ], + [ + 4, + 89, + -1 + ], + [ + 4, + 88, + -1 + ], + [ + 4, + 83, + -1 + ], + [ + 4, + 82, + -1 + ], + [ + 4, + 81, + -1 + ], + [ + 4, + 76, + -1 + ], + [ + 4, + 75, + -1 + ], + [ + 4, + 74, + -1 + ], + [ + 4, + 73, + -1 + ], + [ + 4, + 68, + -1 + ], + [ + 4, + 67, + -1 + ], + [ + 4, + 66, + -1 + ], + [ + 4, + 65, + -1 + ], + [ + 4, + 62, + -1 + ], + [ + 4, + 60, + -1 + ], + [ + 4, + 58, + -1 + ], + [ + 4, + 57, + -1 + ], + [ + 4, + 56, + -1 + ], + [ + 4, + 55, + -1 + ], + [ + 4, + 54, + -1 + ], + [ + 4, + 53, + -1 + ], + [ + 4, + 52, + -1 + ], + [ + 4, + 51, + -1 + ], + [ + 4, + 50, + -1 + ], + [ + 4, + 49, + -1 + ], + [ + 4, + 45, + -1 + ], + [ + 4, + 44, + -1 + ], + [ + 4, + 43, + -1 + ], + [ + 4, + 42, + -1 + ], + [ + 4, + 37, + -1 + ], + [ + 4, + 36, + -1 + ], + [ + 4, + 35, + -1 + ], + [ + 4, + 34, + -1 + ], + [ + 4, + 29, + -1 + ], + [ + 4, + 28, + -1 + ], + [ + 4, + 27, + -1 + ], + [ + 4, + 26, + -1 + ], + [ + 4, + 21, + -1 + ], + [ + 4, + 20, + -1 + ], + [ + 4, + 19, + -1 + ], + [ + 4, + 18, + -1 + ], + [ + 4, + 13, + -1 + ], + [ + 4, + 12, + -1 + ], + [ + 4, + 11, + -1 + ], + [ + 4, + 7, + -1 + ], + [ + 4, + 6, + -1 + ], + [ + 4, + 5, + -1 + ], + [ + 2, + 108, + -1 + ], + [ + 2, + 107, + -1 + ], + [ + 2, + 104, + -1 + ], + [ + 2, + 103, + -1 + ], + [ + 2, + 101, + -1 + ], + [ + 2, + 100, + -1 + ], + [ + 2, + 97, + -1 + ], + [ + 2, + 96, + -1 + ], + [ + 2, + 95, + -1 + ], + [ + 2, + 92, + -1 + ], + [ + 2, + 91, + -1 + ], + [ + 2, + 88, + -1 + ], + [ + 2, + 87, + -1 + ], + [ + 2, + 86, + -1 + ], + [ + 2, + 85, + -1 + ], + [ + 2, + 84, + -1 + ], + [ + 2, + 83, + -1 + ], + [ + 2, + 82, + -1 + ], + [ + 2, + 81, + -1 + ], + [ + 2, + 80, + -1 + ], + [ + 2, + 79, + -1 + ], + [ + 2, + 76, + -1 + ], + [ + 2, + 75, + -1 + ], + [ + 2, + 72, + -1 + ], + [ + 2, + 71, + -1 + ], + [ + 2, + 68, + -1 + ], + [ + 2, + 67, + -1 + ], + [ + 2, + 65, + -1 + ], + [ + 2, + 64, + -1 + ], + [ + 2, + 63, + -1 + ], + [ + 2, + 62, + -1 + ], + [ + 2, + 54, + -1 + ], + [ + 2, + 53, + -1 + ], + [ + 2, + 52, + -1 + ], + [ + 2, + 49, + -1 + ], + [ + 2, + 47, + -1 + ], + [ + 2, + 46, + -1 + ], + [ + 2, + 43, + -1 + ], + [ + 2, + 42, + -1 + ], + [ + 2, + 39, + -1 + ], + [ + 2, + 38, + -1 + ], + [ + 2, + 37, + -1 + ], + [ + 2, + 34, + -1 + ], + [ + 2, + 32, + -1 + ], + [ + 2, + 31, + -1 + ], + [ + 2, + 29, + -1 + ], + [ + 2, + 28, + -1 + ], + [ + 2, + 27, + -1 + ], + [ + 2, + 26, + -1 + ], + [ + 2, + 21, + -1 + ], + [ + 2, + 20, + -1 + ], + [ + 2, + 17, + -1 + ], + [ + 2, + 16, + -1 + ], + [ + 2, + 13, + -1 + ], + [ + 2, + 10, + -1 + ], + [ + 2, + 7, + -1 + ], + [ + 2, + 6, + -1 + ], + [ + 2, + 3, + -1 + ], + [ + 1, + 109, + -1 + ], + [ + 1, + 107, + -1 + ], + [ + 1, + 105, + -1 + ], + [ + 1, + 103, + -1 + ], + [ + 1, + 102, + -1 + ], + [ + 1, + 101, + -1 + ], + [ + 1, + 100, + -1 + ], + [ + 1, + 99, + -1 + ], + [ + 1, + 98, + -1 + ], + [ + 1, + 97, + -1 + ], + [ + 1, + 96, + -1 + ], + [ + 1, + 95, + -1 + ], + [ + 1, + 94, + -1 + ], + [ + 1, + 91, + -1 + ], + [ + 1, + 90, + -1 + ], + [ + 1, + 85, + -1 + ], + [ + 1, + 84, + -1 + ], + [ + 1, + 81, + -1 + ], + [ + 1, + 80, + -1 + ], + [ + 1, + 77, + -1 + ], + [ + 1, + 76, + -1 + ], + [ + 1, + 73, + -1 + ], + [ + 1, + 72, + -1 + ], + [ + 1, + 71, + -1 + ], + [ + 1, + 68, + -1 + ], + [ + 1, + 67, + -1 + ], + [ + 1, + 65, + -1 + ], + [ + 1, + 64, + -1 + ], + [ + 1, + 61, + -1 + ], + [ + 1, + 56, + -1 + ], + [ + 1, + 55, + -1 + ], + [ + 1, + 52, + -1 + ], + [ + 1, + 51, + -1 + ], + [ + 1, + 48, + -1 + ], + [ + 1, + 46, + -1 + ], + [ + 1, + 45, + -1 + ], + [ + 1, + 44, + -1 + ], + [ + 1, + 43, + -1 + ], + [ + 1, + 42, + -1 + ], + [ + 1, + 37, + -1 + ], + [ + 1, + 36, + -1 + ], + [ + 1, + 33, + -1 + ], + [ + 1, + 32, + -1 + ], + [ + 1, + 27, + -1 + ], + [ + 1, + 26, + -1 + ], + [ + 1, + 23, + -1 + ], + [ + 1, + 22, + -1 + ], + [ + 1, + 21, + -1 + ], + [ + 1, + 18, + -1 + ], + [ + 1, + 16, + -1 + ], + [ + 1, + 15, + -1 + ], + [ + 1, + 12, + -1 + ], + [ + 1, + 11, + -1 + ], + [ + 1, + 10, + -1 + ], + [ + 1, + 7, + -1 + ], + [ + 1, + 5, + -1 + ], + [ + 1, + 3, + -1 + ], + [ + 0, + 109, + -1 + ], + [ + 0, + 108, + -1 + ], + [ + 0, + 106, + -1 + ], + [ + 0, + 103, + -1 + ], + [ + 0, + 102, + -1 + ], + [ + 0, + 97, + -1 + ], + [ + 0, + 96, + -1 + ], + [ + 0, + 95, + -1 + ], + [ + 0, + 93, + -1 + ], + [ + 0, + 90, + -1 + ], + [ + 0, + 88, + -1 + ], + [ + 0, + 87, + -1 + ], + [ + 0, + 86, + -1 + ], + [ + 0, + 81, + -1 + ], + [ + 0, + 80, + -1 + ], + [ + 0, + 78, + -1 + ], + [ + 0, + 75, + -1 + ], + [ + 0, + 73, + -1 + ], + [ + 0, + 72, + -1 + ], + [ + 0, + 71, + -1 + ], + [ + 0, + 70, + -1 + ], + [ + 0, + 69, + -1 + ], + [ + 0, + 65, + -1 + ], + [ + 0, + 63, + -1 + ], + [ + 0, + 61, + -1 + ], + [ + 0, + 60, + -1 + ], + [ + 0, + 58, + -1 + ], + [ + 0, + 57, + -1 + ], + [ + 0, + 52, + -1 + ], + [ + 0, + 51, + -1 + ], + [ + 0, + 49, + -1 + ], + [ + 0, + 46, + -1 + ], + [ + 0, + 45, + -1 + ], + [ + 0, + 44, + -1 + ], + [ + 0, + 41, + -1 + ], + [ + 0, + 40, + -1 + ], + [ + 0, + 37, + -1 + ], + [ + 0, + 35, + -1 + ], + [ + 0, + 33, + -1 + ], + [ + 0, + 31, + -1 + ], + [ + 0, + 29, + -1 + ], + [ + 0, + 28, + -1 + ], + [ + 0, + 25, + -1 + ], + [ + 0, + 24, + -1 + ], + [ + 0, + 21, + -1 + ], + [ + 0, + 19, + -1 + ], + [ + 0, + 17, + -1 + ], + [ + 0, + 15, + -1 + ], + [ + 0, + 6, + -1 + ], + [ + 0, + 5, + -1 + ], + [ + 0, + 3, + -1 + ] + ] + }, + "format": "five-stage-two-bank-C3-native-caller-v1", + "parent_width": 36, + "ports_per_bank": 111, + "public_banks": 2 + }, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_consuming_inverse_contract": { + "additional_zero_output_fields": 111, + "covered_independent_public_full_query_rank": 888, + "deficit_if_source_remnant_uncredited": -669, + "gate": "The caller must price111 zero output fields and consume/recycle the111 G*x source remnants. The same111 arbitrary input streams cannot be credited twice as independent FULL and cap query families. No reversible restored-source or restored-zero-buffer interface follows from this one-carrier map.", + "input": "111 arbitrary public source streams x,111 caller-supplied zero target streams,438 arbitrary dirty helpers and one internal zero private field.", + "internal_COPY_rank": 3, + "native_query_histogram": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "ordinary_helper_rank": 3504, + "output": "Target111 streams equal exact nativeFULL F*x. Original source bank contains cap-progress G*x. All438 ordinary helpers obey their width8 native residual and the internal private field is erased.", + "rank_mass": 5061, + "unrestored_consumed_source_fields": 111, + "word": "Free1487ADD source code C; literal inverse of frozen C3 word; free1487ADD target decoder C^-1 at a full local parent output." + }, + "source_decoder_scalar_ADDs": 1487, + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz": "ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "status": "PASS_ACTUAL_C3_RESTORED_FIVE_CALL_NATIVE_WORD_ZERO_RATE_REJECTED", + "uncovered_deficit_before_owner_padding": -33 +} diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE.md b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE.md new file mode 100644 index 0000000000..12ccb83b44 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/MUTABLE-SOURCE.md @@ -0,0 +1,157 @@ +# Exact C511 native interfaces + +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +Producer: `mutable_source_caller.py`; receipt: `MUTABLE-SOURCE-FIVE.json`. +Normal and `python3 -O` compare the complete saved receipt. This is a local, +source-bound operator construction and failed budget, with no new kappa. + +The frozen source is the predecessor's +`recursive/BIT-THREE-COPY-INPUT-WORD.json.gz`, gzip SHA256 +`ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847`. +It has 438 arbitrary ordinary helpers, one reused zero private field, +three rank1 COPY queries, and a 1487-ADD source-only integer code C. Exact +binary replay gives rank(C)=111, rank(C-I)=9 and order(C)=511. This C is +different from the later pruned order28 code A. All 661 endpoint columns, +including the private zero column, are replayed over integers; all binary +VALUE columns are checked separately. The raw literal inverse restores all +438 helper rows and erases its private field as well. + +For one native local stage let F be its full rank8 head/tail exchange, N +the diagonal rank1 source-line exchange, and G=F*N its rank7 cap exchange. +They are commuting involutions. The actual physical source code C commutes +with F, but an explicit routed coefficient witnesses that it does not +commute with N. The forward and inverse physical blocks are exactly + +``` +B_C = [[F C N, 0], [G C N, G]], +B_C^-1 = [[G C^-1,0], [F, G]]. +``` + +In particular, the inverse target cross term is F independently of C. +Direct multiplication proves both identities. The inverse reverses the +literal typed MOVE/ADD/COPY/ERASE word; its helpers have reverse endpoint +frames. Arbitrary physical helper inputs can be interpreted in those +frames, giving the same rank8 paired residual. No initially executed FULL +helper query is inferred from this interpretation. Chronological whole +owner routing for these reverse boundaries is still a separate obligation. + +Its complete local histogram, for either direction, is +`{1:1325,2:1342,3:79,4:44,5:102,6:11,7:9}`, rank mass5061. This includes +all three rank1 private copies. No rank9 scalar defect is substituted for +the actual native word or its port adapters. + +For stage s>=1, the actual upstream Weyl-BFS chart rho_(s,p) obeys +`rho G0,p rho=E_s` and `rho F_s,p rho=I_core8` on every one of the111 ports. +Thus routed C_s commutes with the old cap G0 and every fresh G_t with t!=s. +The receipt checks both rational projector equations at all111 ports and +covers all nonzero C coefficients. A common full parent exchange T also +commutes with every head/tail-separate routed code and its literal inverse. +These facts justify the native composition below; commuting C with N would +not justify it and is explicitly rejected. + +## Five-call restored caller + +Two arbitrary input banks use CLEAN forward, CLEAN backward, CLEAN forward, +then an ordinary bank swap. The normalized result is `diag(N,N)`. +At a fresh stage apply the C3-coded forward call, then at the next stage +one CLEAN forward call. In the universal noncommutative binary operator +ring, using only N^2=I and exact C inverses, + +``` +F_clean * F_C * diag(N,N) = diag(N C,N). +``` + +The product of the five fresh cap exchanges is Gamma. With parent width +36, `Gamma*N=T_parent`; hence the physical output is +`T_parent*diag(C,I)`. Its source code is removed at the full parent cut by +the actual1487-ADD inverse. The ordinary bank swap costs333 scalar ADDs. +Every ordinary helper occurrence remains independent:2190 occurrences of +width8. The private field is reused, with total COPY rank `4*63+3=255`. + +The complete five-call histogram is +`{1:6613,2:6710,3:395,4:220,5:510,6:55,7:81}`; rank mass25545. +Public progress is `2*111*36=7992`, ordinary helper progress17520, so +the uncovered deficit is `7992+17520-25545=-33`. Source decoding and the +swap bring the scalar ADD total to112095. This fails already at zero rate; +owner padding, source scans or rounded errors cannot rescue this invoice. + +Replacing the first, middle or last CLEAN call of the three-call seed by +the coded call without further intermediate code gates does not give this +conclusion: the resulting matrices have a wrong-side C*N term or an +additional C+I block. Multiplying a scalar source code by a formal N is not +a free decoder across this physical cut. + +## Source-consuming inverse interface + +Precode the inverse's source by its free code C. Its exact map is +`(x,y) -> (G*x, F*C*x+G*y)`. If the caller supplies111 additional zero +target fields, a free target C^-1 decoder gives `(G*x,F*x)`. All438 ordinary +helpers and the one internal private field have the stated return contract. + +This leaves111 consumed source streams containing G*x and uses111 caller +zero output fields. The two outputs are linked functions of the same111 +inputs, so they cannot receive two independent public query credits. +Crediting only the FULL output gives `111*8+438*8-5061=-669`, before pricing +the zero output stock. The receipt therefore keeps this as a one-carrier +interface rather than a restored-source supplier. + +For repeated raw inverse calls with the same source bank and fresh native +stages, let B_i=C_i^-1*...*C_0^-1 and B_-1=I. The normalized inverse is +`[[C_i^-1,0],[N,I]]`, and actual interstage commutation gives + +``` +source = Gamma_L * B_(L-1) * x, +target = Gamma_L*y + T_L*(sum_(i=0)^(L-1) B_(i-1))*x. +``` + +The target cross is a full exchange followed by a free head/tail code, but +the source remnant lacks its common N. A zero target or restored source +does not follow from this equation. A coupled rolling bank word closing +all independent source remnants remains open. + +The independent finite code-cut search in `mutable_cut_search.py` permits +legal intermediate C codes before the sole coded cut and N*C*N codes +afterward. At depth3 its500 cut gates give1,500,000 pairs, with no accepted +three-call identity. `mutable_rolling_search.py` separately uses distinct +C0,C1,C2 and all forward/inverse choices:575 gates per cut at depth2, +2,645,000 pairs, no universal identity. Normal and `-O` agree. These are +bounded alphabet/depth searches, not all-word obstructions. + +The raw source-consuming inverse F/B/F word is expanded and independently +tested in `mutable_rolling_boundary.py`: + +``` +R3 = [[I+a1*C0, N*C1], + [N*(C2+C2*a1*C0+C0), I+a2*C1]], a_i=N*C_i*N. +``` + +Exact neighboring cancellation a_(i+1)*C_i=I is incompatible with the +unchanged fresh stage family: C_i commutes G_(i+1), and C_(i+1) commutes +F_(i+1)=N*G_(i+1); substitution forces C_i to commute N, contrary to the +actual coefficient witness. This excludes that exact cancellation only. + +After factoring off parent FULL, the bank0 diagonal is +Phi=N+C1*N*C0. The actual ADDRESS F101 input delta at source port0, +HEAD=e0,TAIL0 produces3131 nonzero output deltas, including port0, +HEAD0,TAIL=e0. All111 Weyl-BFS rho hashes match the fresh C511 receipt. +These15 coordinates embed in parent width22 with the last fresh7 zero. +Free head/tail-separate codes preserve the subspace of impulses with TAIL0, +so a terminal invertible code in that alphabet cannot close the raw word. +Its arithmetic deficit213 is only a failed-candidate diagnostic. + +`mutable_rolling_quotient.py` fixes HEAD=e_j,TAIL0 for each j=0..7 and lets +all111 source-port VALUE coefficients vary. Every actual output impulse +with nonzero TAIL gives a binary coefficient row. Their exact rank is111; +the receipt stores111 independent row witnesses and a digest of all rows. +The control C0=C1=I cancels Phi=N+N on all111*8 sampled impulses. + +For Phi=H_free+sum_i A_i*(c_i^T tensor I_ADDRESS), each projected row lies +in span{c_i}: H_free emits no nonzero TAIL from these inputs, and the i-th +response depends on source coefficients only through c_i. Thus at least111 +ADDRESS-independent common scalar source readouts are necessary. This +excludes a common rank9 scalar quotient repair of this actual raw word. +It gives no native tariff, and permits routed/ADDRESS-dependent readers, +direct source access, extra native source queries and changed coupled words. + +No chronological owner, all-size source/tape bound, rounded error theorem +or outer exponent is supplied by these interfaces or screens. diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/cold_cosets.py b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/cold_cosets.py new file mode 100644 index 0000000000..ee71ce7543 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/cold_cosets.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 +"""Exact E6/D6 coset certificates for the actual binary R429 reader code. + +Written consequences use ordinary E8 parabolic classification and explicitly +price a separate scalar factor by rational source/target pairing rank. +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from collections import Counter +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json + +HERE=Path(__file__).resolve().parent +BASE=Path('/Users/ross/git/math') +RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz' +FULL=BASE/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz' +COMP=BASE/'.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION.json' +PRIME=65537 + +def need(b,m): + if not b:raise ValueError(m) +def bits(x): + while x: + z=x&-x;yield z.bit_length()-1;x^=z +def bxor(xs): + z=0 + for x in xs:z^=x + return z +def rank2(rows): + b={} + for x in rows: + while x: + j=x.bit_length()-1 + if j in b:x^=b[j] + else:b[j]=x;break + return len(b) +def inverse2(rows): + n=len(rows);a=[row|(1<<(n+i))for i,row in enumerate(rows)] + for j in range(n): + p=next(i for i in range(j,n)if a[i]>>j&1) + a[p],a[j]=a[j],a[p] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + need([r&((1<>n for r in a] + +def rankmod(mask,roots,stop=8): + b={} + for p in bits(mask): + v=[x%PRIME for x in roots[p]] + for k,a in sorted(b.items()): + f=v[k] + if f:v=[(x-f*y)%PRIME for x,y in zip(v,a)] + k=next((i for i,x in enumerate(v)if x),None) + if k is not None: + f=pow(v[k],-1,PRIME);b[k]=[(x*f)%PRIME for x in v] + if len(b)>=stop:return len(b) + return len(b) + +def receipt(): + need(sha256(RAW.read_bytes()).hexdigest()=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','raw pin') + w=json.loads(gzip.decompress(RAW.read_bytes())) + full=json.loads(gzip.decompress(FULL.read_bytes()))['lines'] + comp=json.loads(COMP.read_bytes());roots=w['lines'] + rows=[1<>j&1)<

>i&1)<>j&1 for j in range(9)),'all nine special readers have self-pairing1') + orth=[sum((not sum(a*b for a,b in zip(q,r)))<

=7,'a nonzero actual codeword fits two rank<=6 flats') + minimum=min(minimum,r);total+=1 + out[name]={'flats':len(flats),'live_support_sizes':dict(sorted(sizes.items())), + 'minimum_modular_rank_outside_flat':minimum, + 'canonical_flat_data_sha256':sha256(json.dumps(sorted((S,list(pair))for S,pair in flats.items()),separators=(',',':')).encode()).hexdigest()} + need(total==2503900,'all4900 flat/511 nonzero codeword tests') + # A wrong reader outside the code is actually admitted by the low-rank + # support condition, demonstrating that code membership is essential. + fake=(1<<0)|(1<<1) + need(fake not in lookup and rankmod(fake,roots)<=2,'two-source non-code control') + return {'status':'PASS_R429_LOW_RANK_FLAT_COSET_UNIQUENESS_AND_TEN_FACTOR_COLD_FLOOR55', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','no_new_kappa':True, + 'sources':{str(p):sha256(p.read_bytes()).hexdigest()for p in(RAW,FULL,COMP)}, + 'R':R,'K':K,'live_roots':roots,'full_E8_root_lines':full, + 'minimum_D_word_weight':48,'self_pairing_inverse_form_rows':dual, + 'all_nine_special_self_pairings':1,'families':out, + 'rank_field':PRIME,'flat_codeword_tests':total, + 'coset_theorem':'Every coset z+D contains at most one nonzero scalar readout whose source-root support has rational span<=6. E6/D6 frames are covered by the exact4900-flat certificates. Every other rank<=6 root flat has at most21 lines, so two cover at most42<48 source coordinates.', + 'nine_term_floor':'Both sides lie in D; their only span7 directions are the same nine special reader lines. In dual bases a shared label must occupy the same factor because its self-pairing is1. Pairing rank total>=72−union_of_special_labels>=63.', + 'ten_term_floor':'By Sylvester, at least one side has rank9. If both do, every term pairs two spans>=7 and total>=60. Otherwise orient the full-rank side as10 independent source readers spanning D+1: all low<=6 readers lie in its sole nonzero quotient coset, so at most one; full source-span sum>=64. The target side lies in D; generic targets span8 and special targets span7 can each discount at most1. At most9 distinct special targets occur, so total pairing-rank>=55. A duplicate target merges to9 terms without raising projected source rank and instead gives floor63.', + 'cost_model':'Exact binary scalar factorization KR=sum b_i c_i^T; term cost is at least rational rank of pairing between the source-root span U_i and target-root span V_i. This necessary tariff is not a native COPY compiler or a complete supplier.', + 'scope':['No attaining55-cost factorization or word.','The proof uses standard E8 parabolic classification and orthogonal-complement types E6/A2 and D6/A1^2, not a formal-kernel proof.','No restriction on11-or-more terms, shared native queries, operator-valued readers, changed KR or changed caller.'], + 'negative_control':'A two-source non-code word has span<=2 and violates the required outside-span condition; code membership is essential.'} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=json.loads(json.dumps(receipt()));path=HERE/'COLD-COSETS.json' + if args.write:path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else:need(json.loads(path.read_bytes())==out,'stored cold-coset receipt differs') + print(out['status']);print('4900 E6/D6 flats;2503900 rank lower certificates; no two low-span readers in one coset; nine-term63 and ten-term55 necessary floors') +if __name__=='__main__':main() diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/global_kernel_boost.py b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/global_kernel_boost.py new file mode 100644 index 0000000000..81a6dd7913 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/global_kernel_boost.py @@ -0,0 +1,252 @@ +#!/usr/bin/env python3 +"""Literal global-E helper-kernel entrances with actual rational ADDRESS cuts. + +Arbitrary physical dirt is interpreted in each entrance frame. New MOVE charts are rational +GL charts; the retained orthogonal-query compiler is not silently assumed. +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json +from cold_cosets import bits,need +from helper_tail_retime import WORD,RAW,replay,rankQ +from kernel_entrances import parity + +HERE=Path(__file__).resolve().parent + +def basis(rows): + out={} + for row in rows: + row=list(map(Q,row)) + for j,v in sorted(out.items()): + c=row[j] + if c:row=[x-c*y for x,y in zip(row,v)] + j=next((j for j,x in enumerate(row)if x),None) + if j is not None: + c=row[j];row=[x/c for x in row] + for k,v in list(out.items()): + c=v[j] + if c:out[k]=[x-c*y for x,y in zip(v,row)] + out[j]=row + return [out[k]for k in sorted(out)] + +def contains(B,v): + v=list(map(Q,v)) + for b in B: + j=next(j for j,x in enumerate(b)if x) + c=v[j] + if c:v=[x-c*y for x,y in zip(v,b)] + return not any(v) + +def inv(A): + n=len(A);Z=[list(map(Q,row))+[Q(i==j)for j in range(n)]for i,row in enumerate(A)] + for j in range(n): + k=next(i for i in range(j,n)if Z[i][j]);Z[j],Z[k]=Z[k],Z[j] + c=Z[j][j];Z[j]=[x/c for x in Z[j]] + for i in range(n): + if i!=j: + c=Z[i][j] + if c:Z[i]=[x-c*y for x,y in zip(Z[i],Z[j])] + return [r[n:]for r in Z] + +def mm(A,B):return [[sum(x*y for x,y in zip(r,c))for c in zip(*B)]for r in A] +def tr(A):return list(map(list,zip(*A))) +def matkey(A):return [[str(x)for x in r]for r in A] +def eye(n):return [[Q(i==j)for j in range(n)]for i in range(n)] + +def projector(B): + if not B:return [[Q(0)]*8 for _ in range(8)] + return mm(mm(tr(B),inv(mm(B,tr(B)))),B) + +def det(A): + A=[r[:]for r in A];v=Q(1) + for j in range(len(A)): + k=next(i for i in range(j,len(A))if A[i][j]) + if k!=j:A[j],A[k]=A[k],A[j];v=-v + c=A[j][j];v*=c + for i in range(j+1,len(A)): + a=A[i][j]/c + for k in range(j+1,len(A)):A[i][k]-=a*A[j][k] + return v + +def primefactors(v): + v=abs(v);out=[];p=2 + while p*p<=v: + if v%p==0: + out.append(p) + while v%p==0:v//=p + p+=1 if p==2 else 2 + if v>1:out.append(v) + return out + +def frames(raw,d): + roots=raw['lines'];old=raw['frames'];base=[basis(roots[j]for j in f)for f in old] + E=basis(roots[j]for j in range(d)) + need(E==[eye(8)[i]for i in range(d)],'selected common E is literal coordinate plane') + new=dict(raw);new['frames']=[f[:]for f in old] + table={tuple(tuple(r)for r in B):i for i,B in enumerate(base)} + def get(B): + k=tuple(tuple(r)for r in B) + if k not in table: + table[k]=len(base);base.append(B) + new['frames'].append([p for p,q in enumerate(roots)if contains(B,q)]) + return table[k] + ef=get(E);joins=[] + for f in range(len(old)):joins.append(get(basis(base[f]+E))) + return new,ef,joins,base + +def factor_dirty(records): + cols={h:0 for h in range(222,651)} + for op,t,h,c,f,ph in records: + if op==1 and ph==10: + need(c==1 and f==0 and 111<=t<222,'literal compensation atZERO') + cols[h]^=1<<(t-111) + B={};pivots=[];dependent=[];setup=[];witness=[] + for h,v in cols.items(): + z=v;c=0 + while z: + j=z.bit_length()-1 + if j not in B: + B[j]=(z,c^(1<0,'strict join climb') + records.append([0,r,old,f,delta,ph]);current[r]=f + # D*S overF2 has the original pivot columns and zero dependent columns. + records.extend(r[:]for r in base['records']if r[-1]==10 and r[2]not in dependent) + for r,f in enumerate(base['start']):move(r,joins[f],80) + need(all(current[h]==E for h in range(222,651)),'all helpers at the actual common E setup cut') + records.extend([1,k,h,1,E,81]for k,h in setup) + for op,r,s,c,f,ph in base['records']: + if ph==10:continue + if op==0:move(r,joins[c],ph) + else: + need(current[r]==current[s]==joins[f],'old ADD becomes a true joined common-frame ADD') + records.append([1,r,s,c,joins[f],ph]) + need(all(current[h]==1 for h in range(222,651)),'all helpersFULL before inverse setup') + records.extend([1,k,h,-1,1,82]for k,h in reversed(setup)) + new=dict(base);new.update(start=start,records=records,format='R429-global-coordinate-E-kernel-entrances-v1') + return new,geom,E,joins,B,pivots,sorted(dependent),setup,witness + +def native_charts(new,geom,B): + I=eye(8);used={f for r in new['records']for f in([r[2],r[3]]if r[0]==0 else[r[4]])} + Ps={f:projector(B[f])for f in used};frame_rows=[];bad={2};odd=[] + for f in sorted(used): + P=Ps[f];need(mm(P,P)==P and tr(P)==P,'actual rational orthogonal frame projector') + gram=mm(B[f],tr(B[f]));g=det(gram)if gram else Q(1) + need(g>0,'all used rational frames nondegenerate') + for v in [g]+[x for r in P for x in r]: + bad.update(primefactors(v.denominator)) + bad.update(primefactors(g.numerator)) + if any(x.denominator&(x.denominator-1)for r in P for x in r):odd.append(f) + frame_rows.append({'frame':f,'rank':len(B[f]),'root_basis_rref':matkey(B[f]),'projector':matkey(P),'gram_det':str(g)}) + pairs=sorted({(r[2],r[3])for r in new['records']if r[0]==0});charts=[] + for a,b in pairs: + P,Qp=Ps[a],Ps[b] + need(mm(P,Qp)==P==mm(Qp,P),'actual ADDRESS nested-projector compatibility') + W=[[Qp[i][j]-P[i][j]for j in range(8)]for i in range(8)] + need(mm(W,W)==W and tr(W)==W,'actual residual is an orthogonal projector') + rank=len(B[b])-len(B[a]);K=basis(W);Kperp=basis([[I[i][j]-W[i][j]for j in range(8)]for i in range(8)]) + need(len(K)==rank and len(K)+len(Kperp)==8,'actual native residual rank') + C=tr(K+Kperp);Ci=inv(C) + expected=[[C[i][j]if j0,'native MOVE exact frame/containment/rank') + frames[d]=new;H[f]+=1 + else: + need(op==1 and d!=s and frames[d]==frames[s]==f,'common-frame ADD') + rows[d]=plus(rows[d],rows[s],-c if back else c);adds+=1 + prefix=max(prefix,sum(abs(x)for x in rows[d].values())) + need(frames==(program['start']if back else program['final']),'all native endpoint frames') + return rows,{'H':dict(sorted(H.items())),'mass':sum(k*v for k,v in H.items()),'ADDs':adds,'prefix_row_L1':prefix} + +def build(base,raw): + records=[r[:]for r in base['records']];dims=[rankQ(raw['lines'][j]for j in f)for f in raw['frames']] + selected=[(i,r)for i,r in enumerate(records)if r[0]==1 and r[-1]==5] + moved=[] + for i,g in selected: + need(records[i]is g,'earlier leftward moves preserve unprocessed positions') + _,d,s,c,f,ph=g;fd=fs=f;best=None + for j in range(i-1,-1,-1): + r=records[j] + if fd==fs and dims[fd]<=7:best=(j+1,fd) + if r[0]==1: + _,a,b,_,_,_=r + if a==s or b==d:break + else: + need(r[0]==0,'no private opcode in input') + if r[1]==d:need(fd==r[3],'reverse destination frame');fd=r[2] + if r[1]==s:need(fs==r[3],'reverse source frame');fs=r[2] + if j==0 and fd==fs and dims[fd]<=7:best=(0,fd) + if best is not None: + k,nf=best + need(k=222:first.setdefault(d,(i,r)) + groups=defaultdict(list) + for h,(i,r)in first.items(): + need(r[2]==0,'old helper first frameZERO') + need(not any(z[0]==1 and z[-1]!=10 and h in(z[1],z[2])for z in records[:i]), + 'no forward helper incidence before first MOVE') + groups[r[3]].append(h) + witnesses=[];selected={};active=set();setup=[];post=[] + for f,hs in sorted(groups.items()): + ker=kernel([cols[h]for h in hs]) + if not ker:continue + need(rankQ(raw['lines'][p]for p in raw['frames'][f])==1 and len(ker)==1, + 'this constructor uses actual one-dimensional first-frame kernels') + v=ker[0];support=[hs[j]for j in bits(v)];h=support[-1] + need(not selected.keys()&set(support),'disjoint exact entrance groups') + selected[h]=f;active.update(support) + others=[k for k in support if k!=h] + total=0 + for k in support:total^=cols[k] + need(total==0,'actual compensation-kernel column') + setup.extend([1,k,h,1,f,71]for k in others) + post.extend([1,k,h,-1,1,72]for k in reversed(others)) + witnesses.append({'frame':f,'selected_helper':h,'kernel_helpers':support, + 'forward_S_ADDs':[[k,h,1]for k in others], + 'inverse_S_ADDs':[[k,h,-1]for k in reversed(others)], + 'old_compensation_column_weights':[cols[k].bit_count()for k in support]}) + need(len(selected)==10,'ten exact first-frame kernel directions') + first_ids={id(first[h][1])for h in active} + lifted=[first[h][1][:]for h in sorted(active-selected.keys())] + for r in lifted:r[-1]=70 + start=base['start'][:] + for h,f in selected.items():start[h]=f + prefix=[r[:]for r in records if r[-1]==10 and r[2]not in selected] + tail=[r[:]for r in records if r[-1]!=10 and id(r)not in first_ids] + lastC=max(i for i,r in enumerate(tail)if r[-1]==5)+1 + tail[lastC:lastC]=post + new=dict(base);new['start']=start;new['records']=prefix+lifted+setup+tail + new['format']='R429-ten-paired-nonzero-helper-entrances-v1' + return new,witnesses,selected,setup,post + +def receipt(write=False): + need(sha256(WORD.read_bytes()).hexdigest()=='0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e','frozen full box') + need(sha256(RAW.read_bytes()).hexdigest()=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','frozen geometry') + base=json.loads(gzip.decompress(WORD.read_bytes()));raw=json.loads(gzip.decompress(RAW.read_bytes())) + new,witnesses,selected,setup,post=build(base,raw) + rows,rec=replay(new,raw);oldrows,oldrec=replay(base,raw) + need(all(rows[h]=={h:1}for h in list(range(111))+list(range(222,651))), + 'all111 sources and429 arbitrary helpers restored exactly overZ') + expected=[1<=222 for j in rows[p]),'target oldy exact self row') + need(all(not v&1 for j,v in rows[p].items()if j>=222),'new target helper leakage is even') + closed,invrec=replay(new,raw,rows,True) + need(closed==[{j:1}for j in range(651)],'literal signed inverse every column') + H=Counter({int(k):v for k,v in rec['H'].items()});oldH=Counter({int(k):v for k,v in oldrec['H'].items()}) + need(H==oldH-Counter({1:10})and rec['mass']==5087,'exact ten H1 reduction') + wrapper=[] + from fractions import Fraction as Q + from native_seed_binding import eye,mm,rank + def D(P): + n=len(P);C=[[Q(i==j)-P[i][j]for j in range(n)]for i in range(n)] + return[C[i]+P[i]for i in range(n)]+[P[i]+C[i]for i in range(n)] + I=eye(8) + for h,f in sorted(selected.items()): + q=raw['lines'][raw['frames'][f][0]];P=[[Q(x*y,4)for y in q]for x in q] + K=[[I[i][j]-P[i][j]for j in range(8)]for i in range(8)] + need(rank(P)==1 and rank(K)==7 and mm(D(I),D(P))==D(K),'actual paired (E,FULL) native residual rank7') + wrapper.append({'helper':h,'entrance_frame':f,'entrance_root':q,'terminal_frame':1, + 'residual_rank':7,'native_residual':'D_FULL D_E^-1 =D_(E-perp)'}) + # An old ZERO entrance or compensation column is a typed error. + bad=dict(new);bad['start']=new['start'][:];bad['start'][next(iter(selected))]=0 + try:replay(bad,raw) + except ValueError:zero_control=True + else:raise ValueError('oldZERO entrance mutation escaped') + bad=dict(new);bad['records']=[r[:]for r in new['records']if r[-1]!=72] + br,_=replay(bad,raw) + need(any(br[h]!={h:1}for h in range(222,651)),'omitting inverse basis fails integer helper restoration') + # Delete one member of a nontrivial kernel from both S directions while + # retaining the zero compensation column; the target leaks dirty parity. + chosen=next(w for w in witnesses if len(w['kernel_helpers'])>1);d=chosen['kernel_helpers'][0];s=chosen['selected_helper'] + bad=dict(new);bad['records']=[r[:]for r in new['records']if not(r[-1]in(71,72)and r[1]==d and r[2]==s)] + br,_=replay(bad,raw) + need(parity(br)!=expected,'perturbed kernel basis leaks arbitrary helper dirt') + canonical=json.dumps(new,sort_keys=True,separators=(',',':')).encode() + out={'status':'PASS_R429_TEN_LITERAL_PAIRED_RANK1_ENTRANCE_FULL_EXIT_HELPERS', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','no_new_kappa':True, + 'sources':{str(p):sha256(p.read_bytes()).hexdigest()for p in(WORD,RAW)}, + 'all651_signed_integer_columns':True,'literal_inverse':invrec,'profile':rec,'old_profile':oldrec, + 'ordinary_helpers':429,'private_fields':0,'helper_inventory_by_residual_width':{7:10,8:419}, + 'paired_native_wrappers':wrapper,'compensation_kernel_witnesses':witnesses, + 'new_basis_scalar_ADDs':len(setup)+len(post),'word_canonical_sha256':sha256(canonical).hexdigest(), + 'contract':'Ten explicitly listed arbitrary dirty helpers enter at their rank1 first frame E_h and exitFULL. The other419 helpers enterZERO and exitFULL. Each changed residual is D_FULL D_Eh^-1 of rank7; every scalar source/helper row is restored exactly overZ and target is the same clean shear overF2. Source and target physical native cuts are inherited unchanged.', + 'complete_local_price':'Delete10 first H1 queries. Other first MOVEs are merely advanced to the same frame before S; no new recursive query, COPY, private field or target lift. The helper basis S acts at a genuine common E; S^-1 acts atFULL. Initial compensation D*S mod2 has zero selected columns and therefore never reads a nonZERO entrance atZERO. New histogram is the frozen H minus10H1. Source/target coverage111*15 plus419*8+10*7 equals5087, so the old uncovered deficit is unchanged.', + 'entrance_gate':'The owner must implement the physical paired residual D_FULL D_Eh^-1 with public helper dependence cancelled. An arbitrary physical helper u can be interpreted as logical dirt h=D_Eh^-1u; this requires no executed entrance query merely to name h. If one instead insists on the old ZERO logical-dirt identification, ten explicit entrance queries restore the old5097 mass. Chronological paired owner routing remains open.', + 'controls':{'old_ZERO_entrance_rejected':zero_control,'omitted_inverse_basis_fails_Z_helpers':True,'perturbed_kernel_leaks_F2_dirt':True}, + 'limits':['No chronological owner/stock construction for the nonzero entrances.','No changed rounded suffix-error or physical source/tape invoice.','A local residual-width reduction is not an admitted supplier or new exponent.'], + 'attribution':'Underlying R429/E8/signed-word ancestry is pinned in the frozen full compensation source. The helper-boundaries skill compensation-kernel lesson guided the changed entrance. This lane constructs the literal staged S, modified compensation, exact inverse and paired native wrappers.'} + if write: + (HERE/'KERNEL-ENTRANCES-WORD.json.gz').write_bytes(gzip.compress(canonical,mtime=0)) + else:need(gzip.decompress((HERE/'KERNEL-ENTRANCES-WORD.json.gz').read_bytes())==canonical,'saved kernel-entrance word differs') + return json.loads(json.dumps(out)) + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=receipt(args.write);path=HERE/'KERNEL-ENTRANCES.json' + if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(path.read_bytes())==out,'saved kernel-entrance receipt differs') + print(out['status']);print('10 rank7 residuals;419 rank8;0private; all651 signed/F2 columns; local mass5087; owner entrance gate open') + +if __name__=='__main__':main() diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_boundary.py b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_boundary.py new file mode 100644 index 0000000000..73e346c7c4 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_boundary.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 +"""Exact raw AB rolling residual and actual native ADDRESS impulse control. + +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from collections import Counter +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json +from mutable_rolling_search import I,Z,N,c,add,mul,mm,flip,ng,show +from physical_code import actual_routes,serial,bits + +HERE=Path(__file__).resolve().parent +BASE=Path('/Users/ross/git/math') +RAW=BASE/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz' +CODE=BASE/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz' + +def need(p,m): + if not p:raise RuntimeError(m) + +def mv(A,v,p):return tuple(sum(a*b for a,b in zip(row,v))%p for row in A) +def mod(A,p):return [[x.numerator*pow(x.denominator,-1,p)%p for x in row]for row in A] + +def impulse(raw,rows,pin): + rho,P,_=actual_routes(raw);prime=101;m=15 + for i,a in enumerate(rho): + need(sha256(json.dumps(serial(a),separators=(',',':')).encode()).hexdigest()==pin['actual_native_geometry']['ports'][i]['rho_sha256'], + 'actual upstream Weyl-BFS rho agrees with freshly checked C511 native receipt') + r=[mod(a,prime)for a in rho];ps=[mod(a,prime)for a in P] + q=0;v=(1,)+(0,)*(m-1);outputs=[set()for _ in range(111)] + def toggle(j,z): + if z in outputs[j]:outputs[j].remove(z) + else:outputs[j].add(z) + # phi=N+C1*N*C0, acting on bank0's x coefficient after the final + # FULL N is factored off. C0 is the actual scalar core-chart code. + p0=mv(ps[q],v[:8],prime)+(0,)*7 + h0=tuple((a-b)%prime for a,b in zip(v,p0)) + toggle(q,h0+p0) + middle=[] + for k in range(111): + if not(rows[k]>>q)&1:continue + tail=mv(ps[k],v[:8],prime)+(0,)*7 + head=tuple((a-b)%prime for a,b in zip(v,tail)) + middle.append((k,mv(r[k],head,prime),mv(r[k],tail,prime))) + for dest,row in enumerate(rows): + for k,h,t in middle: + if(row>>k)&1:toggle(dest,mv(r[dest],h,prime)+mv(r[dest],t,prime)) + bad=[(j,z)for j,zs in enumerate(outputs)for z in sorted(zs)if any(z[m:])] + need(bad,'raw AB three-call word fails terminal head/tail-free decoding on an actual input impulse') + port,at=bad[0] + packed=[[[*a]for a in sorted(zs)]for zs in outputs] + # Any invertible head/tail-separate ADDRESS code preserves the subspace + # of VALUE impulses with tail ADDRESS0. A nonzero output outside it is + # therefore a concrete control against the required free-decoder code. + return {'odd_ADDRESS_field':prime,'input_port':q,'input_HEAD':list(v),'input_TAIL':[0]*m, + 'operator':'N+C1*N*C0, the bank0<-bank0 block of N_global*R3', + 'nonzero_output_impulses':sum(map(len,outputs)),'output_impulses_with_nonzero_TAIL':len(bad), + 'first_witness':{'port':port,'HEAD':list(at[:m]),'TAIL':list(at[m:]),'VALUE_coefficient_mod2':1}, + 'complete_output_sha256':sha256(json.dumps(packed,separators=(',',':')).encode()).hexdigest(), + 'conclusion':'This block is not head/tail-separate. A terminal invertible code from the admitted head/tail-separate ADDRESS/port alphabet cannot make this raw rolling word a full query on both arbitrary banks.'} + +def receipt(write=False): + need(sha256(RAW.read_bytes()).hexdigest()=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','R438 scientific input pin') + need(sha256(CODE.read_bytes()).hexdigest()=='ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847','C511 source word pin') + raw=json.loads(gzip.decompress(RAW.read_bytes()));word=json.loads(gzip.decompress(CODE.read_bytes())) + pin=json.loads((HERE/'MUTABLE-SOURCE-FIVE.json').read_bytes()) + rows=[1<>pivot)&1:z^=b + if z: + pivot=z.bit_length()-1;basis[pivot]=(z,witness) + summaries.append({'input_HEAD_basis':j,'nonfree_coefficient_rows':nonfree,'nonzero_SOURCE_columns':support.bit_count(),'accumulated_rank':len(basis)}) + # Each row is obtained by fixing one common input ADDRESS and projecting + # one actual output impulse. Any scalar source-readout factorization + # Phi=sum_i A_i (c_i^T tensor I_ADDRESS), modulo a head/tail-free map, + # puts every row in span{c_i}, since a free map cannot emit nonzero tail + # ADDRESS from a tail0 input. Hence t>=the certified binary row rank. + need(len(basis)==111,'full111 common scalar SOURCE-row rank on actual ADDRESS samples') + saved=[{'pivot':p,'reduced_row':v[0],'original_row_witness':v[1]}for p,v in sorted(basis.items(),reverse=True)] + out={'status':'PASS_ACTUAL_ROLLING_COMMON_SCALAR_QUOTIENT_FLOOR','no_new_kappa':True, + 'scientific_pin':pin['scientific_pin'],'C_order':511,'ADDRESS_field':prime, + 'operator':'Phi=N+C1*N*C0, an actual unclosed block of N_global*R3', + 'input_samples':'For each core coordinate j=0..7, all111 source ports carry an arbitrary VALUE coefficient on the same HEAD=e_j,TAIL0 impulse.', + 'projected_outputs':'Every output port/ADDRESS with nonzero TAIL; such an impulse is absent from any admitted head/tail-separate free output map.', + 'sampled_coefficient_row_rank':len(basis),'per_sample':summaries, + 'row_echelon_certificate':saved,'all_nonzero_coefficient_rows':len(rows), + 'complete_coefficient_rows_sha256':sha256(json.dumps(rows,separators=(',',':')).encode()).hexdigest(), + 'identity_code_negative_control':'C0=C1=I gives Phi=N+N=0 on all111*8 sampled impulses, with the actual rho_p*rho_p ADDRESS adapters.', + 'source_receipt_sha256':sha256((HERE/'MUTABLE-SOURCE-FIVE.json').read_bytes()).hexdigest(), + 'bound':'If the correction uses t ADDRESS-independent common scalar source rows c_i, i.e. Phi=H_free+sum_i A_i*(c_i^T tensor I_ADDRESS), every sampled coefficient row lies in span{c_i}; therefore t is at least the displayed exact binary rank.', + 'limits':['No native-query cost follows from this information rank alone.','Routed readouts, ADDRESS-dependent source rows, direct public-input access, extra native source queries and changed coupled words are outside this factorization.','The samples give a lower bound for this actual raw word, not a rank9 code obstruction or all-caller lower bound.'], + 'attribution':'Source code and roots are pinned predecessor data. This lane computes the actual routed operator samples and exact scalar-quotient floor.'} + out=json.loads(json.dumps(out));p=HERE/'MUTABLE-ROLLING-QUOTIENT.json' + if write:p.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(p.read_bytes())==out,'saved scalar-quotient certificate differs') + return out + +if __name__=='__main__': + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');a=ap.parse_args();o=receipt(a.write) + print(o['status'],'common scalar readouts >=',o['sampled_coefficient_row_rank']) diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_search.py b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_search.py new file mode 100644 index 0000000000..c80a7f9678 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/mutable_rolling_search.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +"""Finite three-call rolling search with distinct actual-code stage labels. + +Only universal free-product identities are accepted. Negative output is a +bounded search result, not an actual-C511 or all-word obstruction. +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from pathlib import Path +from hashlib import sha256 +import argparse +import itertools +import json +import time + +HERE=Path(__file__).resolve().parent + +def word(a,b): + x=list(a) + for c in b: + same=x and ((x[-1]==0 and c==0)or(x[-1]!=0 and c!=0 and(x[-1]-1)//510==(c-1)//510)) + if same: + d=x.pop() + if c: + k=((c-1)%510+1+(d-1)%510+1)%511 + if k:x.append(((c-1)//510)*510+k) + else:x.append(c) + return tuple(x) + +def add(a,b):return a^b +def mul(a,b): + r=set() + for x in a: + for y in b: + z=word(x,y) + if z in r:r.remove(z) + else:r.add(z) + return frozenset(r) + +Z=frozenset();I=frozenset([()]);N=frozenset([(0,)]) +ID=(I,Z,Z,I) +def c(i,e=1):return frozenset([(i*510+e%511,)])if e%511 else I +def mm(A,B):return tuple(add(mul(A[2*i],B[j]),mul(A[2*i+1],B[j+2]))for i in range(2)for j in range(2)) +def ng(p):return mul(N,mul(p,N)) +def free(A):return all(all(0 not in w for w in p)for p in A) +def good(A):return free(tuple(mul(N,p)for p in A)) +def flip(A):return A[3],A[2],A[1],A[0] +def show(A):return [[list(map(list,sorted(A[2*i+j])))for j in range(2)]for i in range(2)] + +def library(cut,depth): + gens=[('U(1)',(I,I,Z,I)),('L(1)',(I,Z,I,I))] + for i in range(3): + for e in [1,510]: + p=c(i,e);p=ng(p)if i(G*x,F*C*x+G*y). For one full local parent F and y=0, a free target C^-1 decoder gives (G*x,F*x).', + 'all_parameter_identity':'Gamma5 * F_clean * F_C * N_global = Gamma5 * diag(N*C,N) = T_parent * diag(C,I). The actual full parent T commutes C, so a final free physical C^-1 on bank0 gives diag(T,T).', + 'relations':'N^2=I only for the residual word. Every fresh G_t with t!=coded_stage commutes C_coded, proved below using actual rho. Full parent T commutes the head/tail-separate code C_coded.'} + +def actual_geometry(raw,Crows): + rhos,Ps,_=actual_routes(raw);I8=eye(8);Z7=[[Q(0)]*7 for _ in range(7)] + E=[[Q(i==j and i>=8)for j in range(15)]for i in range(15)] + H=[[Q(i==j and i<8)for j in range(15)]for i in range(15)] + records=[] + for p,rho in enumerate(rhos): + P=Ps[p];K=[[I8[i][j]-P[i][j]for j in range(8)]for i in range(8)] + G0=[K[i]+[Q(0)]*7 for i in range(8)]+[[Q(0)]*15 for _ in range(7)] + Np=[P[i]+[Q(0)]*7 for i in range(8)]+[[Q(0)]*15 for _ in range(7)] + Fs=[[Np[i][j]+E[i][j]for j in range(15)]for i in range(15)] + need(mm(mm(rho,G0),rho)==E,'actual rho maps old capG0 to common freshE') + need(mm(mm(rho,Fs),rho)==H,'actual rho maps native localFULL to common core8') + need(mm(rho,eye(15))==mm(eye(15),rho),'actual full head/tail exchange conjugation') + records.append({'port':p,'rho_sha256':sha256(json.dumps(serial(rho),separators=(',',':')).encode()).hexdigest(), + 'G0_conjugate':'E_fresh7','local_FULL_conjugate':'I_core8'}) + # All C[p,q] coefficients are scalar in local coordinates. The two + # preceding per-port conjugations prove EVERY nonzero routed coefficient + # intertwines both G0 and localFULL, not merely a sample edge. + edge_count=sum(v.bit_count()for v in Crows) + need(edge_count>111,'nontrivial actual source code') + witness=None + for p,v in enumerate(Crows): + for q in bits(v): + if p==q:continue + R=mm(rhos[p],rhos[q]);P,Qp=Ps[p],Ps[q] + PN=[P[i]+[Q(0)]*7 for i in range(8)]+[[Q(0)]*15 for _ in range(7)] + QN=[Qp[i]+[Q(0)]*7 for i in range(8)]+[[Q(0)]*15 for _ in range(7)] + a,b=mm(PN,R),mm(R,QN) + if a!=b: + i,j=next((i,j)for i in range(15)for j in range(15)if a[i][j]!=b[i][j]) + witness={'edge':[p,q],'ADDRESS_entry':[i,j],'left':str(a[i][j]),'right':str(b[i][j])};break + if witness:break + need(witness is not None,'actual C does not commute commonN: wrong orientation is observable') + return {'ports':records,'all_nonzero_C_coefficients_covered':edge_count, + 'all_stage_intertwining':'For coded stage s>=1, every rho_s,p G0,p rho_s,p=E_s and rho_s,p F_s,p rho_s,p=H8. Scalar C commutes commonE_s and H8, so routed C_s commutes G0 and F_s exactly. Fresh G_t for t>=1,t!=s is disjoint from rho_s support and commutes every coefficient. T_parent is a full exchange on all used axes and commutes every diag(rho,rho) ADDRESS adapter.', + 'commonN_noncommutation_control':witness} + +def receipt(write=False): + need(sha256(RAW.read_bytes()).hexdigest()=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','actual R438 pin') + need(sha256(CODE.read_bytes()).hexdigest()=='ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847','actual three-source-copy word pin') + raw=json.loads(gzip.decompress(RAW.read_bytes()));coded=json.loads(gzip.decompress(CODE.read_bytes()));old=old_word(raw) + rows,codebill=replay(coded,raw);oldrows,oldbill=replay(old,raw) + need(all(rows[h]=={h:1}for h in range(222,660))and not rows[660],'all438 arbitrary helper and zero private integer rows restored') + need(all(all(j<111 for j in row)for row in rows[:111]),'coded SOURCE has no target/helper contamination overZ') + Crows=parity(rows[:111]);need(rank2(Crows)==111 and rank2([r^(1< 0, + 'actual MOVE containment/rank') + frames[d] = new + H[f] += 1 + moves += 1 + else: + need(op == 1 and d != s and frames[d] == frames[s] == f, + 'actual common-frame ADD') + out[d] = add(out[d],out[s],-c if backward else c) + adds += 1 + peak = max(peak,sum(abs(v) for v in out[d].values())) + need(frames == (program['start'] if backward else program['final']), 'actual final frames') + need(H == NEW_H and (adds,moves) == (12932,2984), 'complete changed local profile') + return out, {'ADD':adds,'MOVE':moves,'histogram':dict(sorted(H.items())), + 'mass':sum(r*n for r,n in H.items()),'signed_integer_prefix_L1':peak} + +def port_identities(w): + from physical_code import actual_routes + rhos,projectors,_=actual_routes(w) + I = eye(8) + hashes = [] + for rho,P in zip(rhos,projectors): + A = [row[8:] for row in rho[:8]] + need(all(x.denominator & (x.denominator-1) == 0 for row in rho for x in row), 'dyadic chart') + K = [[I[i][j]-P[i][j] for j in range(8)] for i in range(8)] + need(mm(P,P) == P and rank(P) == 1 and rank(K) == 7, 'actual P/K projectors') + need(mm(A,tr(A)) == K and mm(tr(A),A) == eye(7), 'actual cap isometry') + need(not any(x for row in mm(P,A) for x in row), 'P A=0') + # These checked block relations imply exactly, for this actual rho: + # rho diag(K,0) rho=diag(0,I7), + # rho diag(I8,0) rho=diag(P,I7). + # Consequently the source and old cap target progress are G=D_E7; + # the FULL target progress is G N, N=D_P. No scalar rank9 code is used. + body=json.dumps([[str(x) for x in row] for row in rho],separators=(',',':')).encode() + hashes.append(sha256(body).hexdigest()) + need(len(hashes) == 111, 'all111 actual ports') + return hashes + +def row_xor(a,b): + return [x ^ y for x,y in zip(a,b)] + +def left(row, generator_mask): + return [{x ^ generator_mask for x in coefficient} for coefficient in row] + +def native_star(L=9, omit_terminal=False, wrong_full_target=False): + need(L >= 3, 'three seed stages') + n = L-1 + rows = [[{0} if i == j else set() for j in range(n)] for i in range(n)] + levels = [-1]*n + events = [] + H_idle = Counter() + def idle(bank, last): + old = levels[bank] + if last == old: + return + need(last > old, 'native idle chronology') + mask = sum(1 << (s+1) for s in range(old+1,last+1)) + rows[bank] = left(rows[bank],mask) + d = 7*(last-old) + H_idle[d] += 111 + levels[bank] = last + events.append({'kind':'native_idle','bank':bank,'old':old,'new':last, + 'children':111,'rank_each':d,'actual_projector':'orthogonal sum of listed G_s supports'}) + def call(stage, kind, source, target): + idle(source,stage-1) + idle(target,stage-1) + g = 1 << (stage+1) + x,y = rows[source],rows[target] + if kind == 'OLD_F': + rows[source] = left(x,g) + rows[target] = row_xor(left(y,g),left(x,g|1)) + elif kind == 'OLD_B': + rows[source] = row_xor(left(x,g),left(y,g|1)) + rows[target] = left(y,g) + else: + need(kind == 'NEW_F','actual declared local alphabet') + rows[source] = left(x,g) + rows[target] = row_xor(left(x,g),left(y,g if wrong_full_target else g|1)) + levels[source] = levels[target] = stage + events.append({'kind':kind,'stage':stage,'source':source,'target':target, + 'source_progress_rank':7,'target_progress_rank':8 if kind == 'NEW_F' else 7, + 'cross':'G_s' if kind == 'NEW_F' else 'G_s N_p', + 'helpers':429 if kind == 'NEW_F' else 438, + 'literal_local_word':str(WORD) if kind == 'NEW_F' else str(RAW)}) + call(0,'OLD_F',0,1) + call(1,'OLD_B',0,1) + call(2,'OLD_F',0,1) + rows[0],rows[1] = rows[1],rows[0] + events.append({'kind':'whole_bank_SWAP','banks':[0,1],'field_SWAPS':111, + 'binary_VALUE_implementation_XOR_ADDs':333}) + for j in range(2,n): + call(j+1,'NEW_F',0,j) + for bank in range(n): + idle(bank,L-1) + for j in reversed(range(2,n)): + if omit_terminal and j == 2: + continue + rows[j] = row_xor(rows[j],rows[0]) + events.append({'kind':'terminal_common_front_CNOT','source':0,'target':j, + 'ADDs':111,'native_children':0}) + final_mask = (1 << (L+1))-1 + expected = [[{final_mask} if i == j else set() for j in range(n)] for i in range(n)] + return rows,expected,events,H_idle + +def receipt(): + need(sha256(RAW.read_bytes()).hexdigest() == 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','R438 raw pin') + need(sha256(WORD.read_bytes()).hexdigest() == '0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e','changed word pin') + w = json.loads(gzip.decompress(RAW.read_bytes())) + program = json.loads(gzip.decompress(WORD.read_bytes())) + need(len(program['start']) == len(program['final']) == 651,'all ordinary roles') + need(all(f == 0 for f in program['start'][111:]), 'all target/helper entries atZERO') + a,forward = replay(w,program) + _,inverse = replay(w,program,True) + need(all(a[p] == {p:1} for p in list(range(111))+list(range(222,651))), + 'all source and429 arbitrary helper columns restored exactly overZ') + for p in range(111): + parity = {k for k,v in a[111+p].items() if v & 1} + need(parity == {p,111+p},'actual target y+x overF2') + back,_ = replay(w,program,True,a) + need(back == [{i:1} for i in range(651)],'literal full integer inverse all651 columns') + try: + replay(w,program,omit_lift=True) + except ValueError as error: + lift_control = str(error) + else: + raise ValueError('omitted actual target lift escaped') + port_hashes = port_identities(w) + rows,expected,events,H_idle = native_star() + need(rows == expected,'actual native ADDRESS exchange group algebra all eight raw banks') + bad,_,_,_ = native_star(omit_terminal=True) + need(bad != expected,'missing common-front CNOT rejected') + bad,_,_,_ = native_star(wrong_full_target=True) + need(bad != expected,'dropping physical target common N rejected') + for L in (3,5,7,11,13): + z,e,_,_ = native_star(L) + need(z == e,'native operator star all checked arities') + local = Counter({r:3*OLD_H[r]+6*NEW_H[r] for r in set(OLD_H)|set(NEW_H)}) + return {'status':'PASS_NATIVE_E8_SEEDED_STAR_OPERATOR_BINDING_WITH_IMPORTED_OLD_CLEAN_INTERFACE', + 'scientific_pin':PIN,'no_new_kappa':True, + 'sources':{str(p):sha256(p.read_bytes()).hexdigest() for p in (RAW,WORD,OLD_STAR,HERE/'physical_code.py')}, + 'changed_local_all651_Z_columns_replayed':True, + 'changed_local_forward':forward,'changed_local_literal_inverse':inverse, + 'changed_local_helpers_restored':429,'private_fields':0, + 'all111_actual_rho15_hashes':port_hashes, + 'actual_native_local_blocks':{ + 'old_F':'[[G_s,0],[G_s N_p,G_s]]', + 'old_B':'[[G_s,G_s N_p],[0,G_s]] over binary VALUE', + 'new_F':'[[G_s,0],[G_s,G_s N_p]]', + 'N_p':'actual D_(q_p q_p^T/4) on the common8-space', + 'G_0':'D_(I8-q_p q_p^T/4), rank7', + 'G_s_s_positive':'D_(fresh E_s), rank7 after the actual rho15 chart', + 'full_parent':'N_p G_0 ... G_(L-1) = D_I_m, m=1+7L, on each physical port'}, + 'word':events, + 'binary_VALUE_public_banks':8, + 'conditional_local_histogram_before_helpers_hosted':dict(sorted(local.items())), + 'public_idle_histogram_before_helpers_hosted':dict(sorted(H_idle.items())), + 'new_words_total_ADD':6*12932, + 'terminal_CNOT_ADD':6*111,'bank_SWAP_field_scans':111, + 'raw_deficit_if_all_owners_exact':2*111-3*63, + 'native_scope':'All111 actual E8 ports and exact dyadic rho block identities; literal changed651-role scalar/frame stream; native outer word in the group algebra of explicitly orthogonal ADDRESS exchanges, valid on all binary VALUE functions over every odd ADDRESS field. No scalar-rank9 replacement or dropped target lift is used.', + 'remaining_premises':[ + 'The old CLEAN R438 F/B contract and its signed/native compiler remain imported, not newly independently compiled here.', + 'No chronological whole-helper owner allocation, complete hosted histogram, fallback or stock certificate.', + 'No rounded child-error/suffix weights, source-access/tape realization or all-size supplier admission.', + 'The root independently rejects this seeded profile at primitive exponent .002; this reusable binding is not a positive exponent claim.'], + 'executed_controls':{'omitted_target_lift':lift_control, + 'omitted_terminal_CNOT':True,'wrong_full_target_G_instead_of_GN':True}} + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write',action='store_true') + args=ap.parse_args() + out=json.loads(json.dumps(receipt())) + path=HERE/'NATIVE-SEED-BINDING.json' + if args.write: + path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == out,'stored native binding differs') + print(out['status']) + print('111 actual rho charts;651 integer columns;8 native raw-input banks; all lifts paid') + +if __name__=='__main__': + main() diff --git a/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/old_kernel_boost.py b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/old_kernel_boost.py new file mode 100644 index 0000000000..2b497fb9ba --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/changed/bit-native-caller/old_kernel_boost.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python3 +"""Global common-E compensation-kernel entrances for the old CLEAN R438 word. + +All nine nested copied totals and all changed target caps remain priced. +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import argparse +import gzip +import json +from global_kernel_boost import HERE,RAW,basis,contains,frames,native_charts,matkey,eye +from cold_cosets import bits,need +from helper_tail_retime import plus +from kernel_entrances import parity + +N=660 + +def old_word(raw): + B=[basis(raw['lines'][p]for p in f)for f in raw['frames']] + current=raw['start'][:];records=[] + def move(r,f): + old=current[r] + if old!=f: + need(all(contains(B[f],q)for q in B[old]),'old original climb nested') + records.append([0,r,old,f,len(B[f])-len(B[old]),0]);current[r]=f + def phase(name,ph,c=1): + for f,d,ss in raw[name]: + for r in[d]+ss:move(r,f) + for s in ss:records.append([1,d,s,c,f,ph]) + phase('D',10);phase('A',2) + for i,h in enumerate(raw['ret']): + f=current[h];records.append([2,h,N,f,0,3]) + for p,ss in enumerate(raw['scatter']): + if i in ss: + need(current[111+p]==0,'old totals scatter at actualZERO') + records.append([1,111+p,N,1,0,3]) + records.append([3,h,N,f,0,3]) + phase('B',4);phase('C',5,-1) + for r,f in enumerate(raw['final']):move(r,f) + return {'start':raw['start'][:],'final':raw['final'][:],'records':records} + +def replay(program,geom,initial=None,back=False): + B=[basis(geom['lines'][p]for p in f)for f in geom['frames']] + current=(program['final']if back else program['start'])[:]+[None] + rows=[{j:1}for j in range(N)]+[{}]if initial is None else[r.copy()for r in initial] + H=Counter();adds=copies=0;peak=1;opened=None;copyrows=[] + for op,d,s,c,f,ph in reversed(program['records'])if back else program['records']: + if op==0: + a,b=(c,s)if back else(s,c) + lo,hi=(b,a)if back else(a,b) + need(current[d]==a and len(B[hi])-len(B[lo])==f>0 and all(contains(B[hi],v)for v in B[lo]),'actual old/new MOVE') + current[d]=b;H[f]+=1 + elif op==1: + need(d!=s and current[d]==current[s]==f,'actual common-frame ADD including copied scatter') + need(opened is None or d!=opened,'copied total immutable untilERASE') + rows[d]=plus(rows[d],rows[s],-c if back else c);adds+=1 + peak=max(peak,sum(abs(x)for x in rows[d].values())) + elif op==(3 if back else 2): + need(opened is None and s==N and not rows[N] and current[N]is None and current[d]==c,'fresh zero private COPY actual source frame') + need(all(contains(B[c],v)for v in B[f]),'nested paid COPY target') + tariff=len(B[c])-len(B[f]);need(tariff>0,'positive COPY tariff') + rows[N]=rows[d].copy();current[N]=f;opened=d;H[tariff]+=1;copies+=1 + copyrows.append({'source_helper':d,'source_frame':c,'private_frame':f,'query_rank':tariff}) + else: + need(op==(2 if back else 3)and opened==d and s==N and rows[N]==rows[d]and current[d]==c and current[N]==f,'literal ERASE original unchanged snapshot') + rows[N]={};current[N]=None;opened=None + need(current[:-1]==(program['start']if back else program['final'])and current[N]is None and opened is None,'every old/new endpoint') + return rows,{'H':dict(sorted(H.items())),'mass':sum(k*v for k,v in H.items()),'ADDs':adds,'COPYs':copies,'private_fields':1,'COPY_records':copyrows,'prefix_row_L1':peak} + +def dirty_factor(base,geom): + noD=dict(base);noD['records']=[r for r in base['records']if r[-1]!=10] + rows,_=replay(noD,geom) + cols={h:sum((rows[111+p].get(h,0)&1)<

0,'strict old-clean climb') + records.append([0,r,old,f,tariff,ph]);current[r]=f + records.extend(r[:]for r in base['records']if r[-1]==10 and r[2]not in deps) + for r,f in enumerate(base['start']):move(r,joins[f],80) + need(all(current[h]==E for h in range(222,N)),'actual commonE helper setup') + records.extend([1,k,h,1,E,81]for k,h in setup) + for op,r,s,c,f,ph in base['records']: + if ph==10:continue + if op==0:move(r,joins[c],ph) + elif op==1: + nf=E if s==N else joins[f] + need(current[r]==nf and(s==N or current[s]==nf),'joined old-clean common scalar frame') + records.append([1,r,s,c,nf,ph]) + else: + need(op in(2,3)and current[r]==joins[c],'actual joined copied-total cut') + records.append([op,r,s,joins[c],E,ph]) + need(all(current[h]==1 for h in range(222,N)),'old helperFULL inverse setup') + records.extend([1,k,h,-1,1,82]for k,h in reversed(setup)) + final=[joins[f]for f in base['final']] + new={'start':start,'final':final,'records':records,'format':'R438-global-coordinate-E-kernel-entrances-hybrid-v1'} + return new,geom,E,joins,B,piv,dep,setup,witness + +def receipt(d,write=False): + need(sha256(RAW.read_bytes()).hexdigest()=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','old R438 exact source') + raw=json.loads(gzip.decompress(RAW.read_bytes()));base=old_word(raw) + oldrows,oldrec=replay(base,raw) + need(oldrec['H']=={1:1322,2:1342,3:79,4:44,5:102,6:11,7:18}and oldrec['mass']==5121,'entire retained clean profile') + expected=[1<>q&1 for p,q in edges),'actual source-code commutant edges') + cr,cp=commutant_rank(rhos,edges) + need(cr==224,'mod101 rank224 gives rational commutant dimension1') + # The identity is in the rational commutant, so its dimension is exactly1, + # not merely at most1. A common native projector commuting these couplings + # is therefore scalar, and idempotence leaves onlyZERO/FULL. + identity_coeff=[int(i==j)for i in range(15)for j in range(15)] + need(sum(identity_coeff)==15,'nonzero exact identity commutant control') + Hhash=[];coverage=[] + for p,rho in enumerate(rhos): + rs,rt=embed(rho,0),embed(rho,1);H=mm(rt,rs) + # H maps every old fresh basis column into the new fresh subspace. + need(all(H[i][j]==int(i==j+7)for i in range(22)for j in range(8,15)), + 'actual H sends completed old fresh exactly to future fresh') + P0=[[projectors[p][i][j]if i<8 and j<8 else Q(0)for j in range(22)]for i in range(22)] + need(mm(H,P0)==mm(P0,H),'actual H commutes common N_p projector') + Hhash.append(sha256(json.dumps(serial(H),separators=(',',':')).encode()).hexdigest()) + for p,q in edges: + rs_p,rs_q=embed(rhos[p],0),embed(rhos[q],0) + rt_p,rt_q=embed(rhos[p],1),embed(rhos[q],1) + hp,hq=mm(rt_p,rs_p),mm(rt_q,rs_q) + need(mm(hp,mm(rs_p,rs_q))==mm(mm(rt_p,rt_q),hq), + 'actual all-input ADDRESS intertwiner coefficient identity') + M=mm(rhos[3],rhos[0]) + witness=next((i,j,M[i][j])for i in range(8,15)for j in range(8)if M[i][j]) + return {'status':'PASS_PHYSICAL_REPAIRED_A_INTERTWINER_AND_EXPLICIT_COVERAGE_DEBT', + 'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','no_new_kappa':True, + 'sources':{str(p):sha256(p.read_bytes()).hexdigest()for p in(RAW,FULL,GEOMETRY,COMP,CODE)}, + 'R':R,'K':K,'W':W,'A':A,'J_rank':108,'A_rank':111,'literal_source_code_ADDs':1499, + 'A_order':28,'power_diagnostics':powers, + 'native_factor':'Let F be actual local FULL, N=diag(D_Pp), G=F N, a=N A N. Since F commutes scalar A and N, repaired local Fphys=diag(G,G) F_N diag(a,I). It has source A G and cross G A N. This statement uses the same actual rho conjugacy on all factors at later stages.', + 'routed_source_code':'A_s[p,q]=A[p,q] times VALUE push(rho_s,p rho_s,q). These exact rho_s,p are reconstructed from upstream geometry.py Weyl BFS, not chosen fresh gauges.', + 'all111_actual_rho15':[[[str(x)for x in row]for row in rho]for rho in rhos], + 'intertwiner':'H_p=rho_t,p rho_s,p: H A_s H^-1=A_t, H commutes N_p, and H(E_s)=E_t. H is an orthogonal ADDRESS transform; all its access and head movement remain paid.', + 'all111_intertwiner_H_sha256':Hhash, + 'coverage_debt':'H^-1 D_Et H D_Es=I on arbitrary VALUE functions, while the desired D_(Es+Et) has native rank14. The naive alignment/query/unwind word cancels its two rank7 fresh advances. This prices that word only.', + 'uniform_source_frame_commutant':{'active_dimension':15,'matrix_unknowns':225, + 'field_for_rank_lower_certificate':101,'actual_A_edges':edges, + 'modular_constraint_rank':224,'rank_progress':cp,'rational_commutant_dimension':1, + 'consequence':'A common orthogonal projector Q commuting the actual source-code coupling maps is scalar, hence Q=0 orI15. The routed source code cannot be treated as a code preserving an unchanged intermediate common native frame.'}, + 'actual_future_fiber_witness':{'output_port':3,'input_port':0,'row':witness[0], + 'column':witness[1],'coefficient':str(witness[2])}, + 'AN_native_orbit_screen':orbit_screen(A,w,full), + 'exact_commutator_fact':'For a scalar port code T, [T,N]_(p,q)=T_pq(D_Pq-D_Pp). Distinct actual E8 lines give distinct native permutations. Every A^k,1<=k<28, has an offdiagonal entry, so none commutes N. Low rank(A^14-I)=2 does not make its routed native coefficient a rank2 query.', + 'open_next_question':'Construct a caller using genuinely changing/port-dependent native frames or shared operator-valued readers so H coverage loss is compensated inside the actual word. No such positive complete word is supplied here.', + 'limits':['No general obstruction for arbitrary operator-valued or nonlinear callers.', + 'No chronological helper owners, rounded errors, source/tape bill, full recurrence or new conditional exponent.', + 'The AN test is a finite exact counterexample to periods<=224, not a proof of infinite order or a universal word lower bound.']} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=json.loads(json.dumps(receipt()));path=HERE/'PHYSICAL-CODE.json' + if args.write:path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else:need(json.loads(path.read_bytes())==out,'stored physical code receipt differs') + print(out['status']);print('literal A order28; actual rho intertwiner; native coverage debt14; commutant dimension1; AN periods<=224 rejected') +if __name__=='__main__':main() diff --git a/research/c511-mutable-source-boundary/frozen/old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz b/research/c511-mutable-source-boundary/frozen/old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz new file mode 100644 index 0000000000..b00c1787ad Binary files /dev/null and b/research/c511-mutable-source-boundary/frozen/old/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz differ diff --git a/research/c511-mutable-source-boundary/frozen/reviews/native/RESULT.json b/research/c511-mutable-source-boundary/frozen/reviews/native/RESULT.json new file mode 100644 index 0000000000..c65d20607c --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/reviews/native/RESULT.json @@ -0,0 +1,328 @@ +{ + "C_defect_rank": 9, + "C_order": 511, + "C_rank": 111, + "actual_C_N_noncommutation": { + "ADDRESS_entry": [ + 0, + 8 + ], + "edge": [ + 0, + 1 + ], + "left": "1", + "right": "0" + }, + "all111_Weyl_BFS_rho_sha256": [ + "045275fd94695bfbcf07404853eb28165a6afddaa0c86bced1bc24697b5f6f8d", + "dc7aa20cef213ebb471083aeac0f32852b4336ef37376a9f5acd44e89827070f", + "92f07a2c521dac9488b56f5bea199dcc564dc8ad83df722c9b7ff42690ebd532", + "46f272e0c19b62206b01de5f92cba70a7e2e9750728a1fcf6df53c78a8f86311", + "cddeaf0cff7d9bd06709c7012d7613cf04eb7eda136d1e198ce1656866a55434", + "c25ed876d162922083ec10f0a8ff6a57b5979f5f4a3ff7faa33b495dcd7266a9", + "7de45f3eaa4e6e37af658ade56e07c0fb1f06de1528ab373f06a0947957f832f", + "5dbcb0301f1be2864f5360f4d641602735c290daf96a9b6355f41b50fef10157", + "51baa68f01838845f78c3e87f2bfaff4770fe4dac2792658a30f17064e556b61", + "16874f1d3c429218846ce4eb3f6550f49ac0e811b6182a7a60e77be889ae7ec2", + "7a5d5c3f62db3a028d629cfa825a39b8f3e98d2e4b98f880fcc84b0a04103569", + "5f0e10520406a278a90c9513fe074cad041cc2a24b7de1648bd1727cf37bb71d", + "39387f31d0f2ee94e5650f9fc5f0f59f0f0c96718f370b3fb47dda08639b4dd3", + "89631256d1464eb901b4949b0a3293acbe0c49a95e595aa0ae0046644fdde30f", + "d579231f91cd36155735f8cc94e0cdac0d57c3ca97a0e807758f25a383fc7494", + "fc0103f42e8c46daa86a678fcbbf8a72525beba7f0a3ea2169df5c3c2f1642aa", + "115a3cdfe66a4d63de7e97283ad11e7f20c3677cb6aacad9e9e43c64a02180b7", + "1f935e6d2750a6f99f79573a2d6dd070701239edf9fdfa9ca2f2b0a7211a40be", + "97f501cedd9b6ee536a5193cc9fa4042ab04e5fb0f721050db51fa187d1d7eaa", + "722f86d22b4c333edab2ff5994953fd99d6b281309dbfb11a0b5862094cd8b6e", + "047f65b62ede8d8aaa70a775b3b2299127c8ebdac57b201d483f2603adcd9769", + "44e027bd2e51c119f74d20ca5a0d6b4823f7376754125baf8380c6edf0a1364c", + "c1638f25897fb7146944d6964143e3d43f4bcdea08e57379e8cd41780b289a68", + "743109c64a215a59ce50668f1c5c0a0a5f64ae45b66fff6ca46bf96dc9469f06", + "4bc7f4f1060d2d042a03cd8833f4c03968c4a05465b7f3e14e9a2a46f03f63ed", + "be589b065082d43e50cb69f8f6b59ad0cdab8b9030b11984cfa70da10dea302a", + "194c5a97b582ead4fc317b7e352944edae6ae80f40b80eeb376f080ffbb6a810", + "6d135995aecd80559cad7632e41ac6e08944abfc771f1501f5f6296e16b93d94", + "4b32902c01d3db70455c77b85f35f5e98ec51f7671f78aa8e6bbf61aac354fd6", + "e8ce73e7fbfb3383bab479a0cdd31456aa246995c43610e7c2cdc1cafb0161dd", + "8cc2b529b6738bcd8d57694e94112c621031cbb8871fef8d62b9c2b5a75442a4", + "134bd4ac6de3ceb6cc1d001c3cadf94360416d770a4705d1acb07d282e85fe99", + "a4f2c0cd439301d4b8f8ea02085c7b7817fb20e112f5bb77e353ff5c3610f6f0", + "6a2935b28e9b63201e54f2bb78ad008830befb44aac1810942d3f9dcba03a6a6", + "dbbcd773f3b29f89d6f025ebdddbf6b6d7e74b78cb7572b0ffa2b3f4f722cd84", + "700253a6e1d4b0db603c96bb130990fa58ffee95db1c874e951864f7e823a486", + "1e02e79f2342dbb8ab06f40163c99f2f11d92e8ca6b14da29e9d09565e1c2b93", + "8276a17c21c550851ffdab60c653281e54704e22a0dbf57d37ed5a1192343d40", + "d2945271d6e26f574d4755f7673f323399efb00d192a19e79bab3af9e3b0aeb9", + "873f27215e8781e5080b0f47c46eea92f0d802dbe47d17232b94240c678ab382", + "a0bb5d60493f0ddf92ad46d490c2a451a0a695175a5d7c6f3539934b75f2f0c5", + "f7d0da53e99dc999ed8a5442fb5c141d3a02fe6ab897d11444015eea6723d1ae", + "066b09c4f2dc99f19d29011b5a4083fbb0c202dfc1eae9863939e6dc008d46c2", + "8979b02de7756217f5b5590c15361d444440b92a626d28e89338227a0132a0f6", + "116b9f7aaa4def010ca9108e1db2630f54e9369ae4dfb3c4882d26af7d2ab3ce", + "477a64d9dfd9ad229dc32aa50c12c5268c46528b1c9ee45e5cca86d5e8cb6e88", + "0e5229e4f9f1a45a6b6ff8fd1328e526e064b131ab1ebce463bbf94820e5799e", + "6e1ccea1c302239f9b93f14f776d36f41aa91fa1df01bf6eda00a41437d06d92", + "2ce864880fabd0a3c4564e200a64783f6f97419bad3c6b8c24eda86861268cd7", + "4067229e86eec48a6c8953f5db44ddbacd2b58a1fdbe17221d6e3297f0977642", + "09c9388b54e50a25be883ce85e992c5abe7b703e7f4667da1f6cef6c287fe3b7", + "be88247ac3085db25dbee6ccb33427e043dc0b0df4143f7fa7b14b053ba9eeae", + "09bb86ae1eefab1adff90ef86a886063e902b3672d87581849be37c73333a59a", + "af356c97e3cb8465479b6d9d32c3f9dc7962addcc503a98725509c800cafa931", + "ce542dad37f33d62db2849409098d19cf96cbe67121039df1bb04b22fb910953", + "a446d8a1cd0d8080f6babc70e69506f3de0fe2f45be0a627f3157114cc3414b0", + "fe09743261865b89616c0803fe71f34a914cd11ce08df9a4a65f91a78f32f42c", + "65da7a86e00f4dba5bf8c315162d2e1ad2c3573cd22481378e49cb740517934e", + "8d659a132782f23cc0f915e8d7c1355685767a294f66d18d9437386cce4b08dc", + "728545c23ddb7897b451b7c2e9227f26fcbd67b205e05cf1006b2c2bf946ca69", + "3bd5358d10006616ebe4552dbe41917841fb23da3fd84085678bf453b3ed5c75", + "c6fa8a470ef2c40b735c707a55b2ee89c8038b9a5d45b8ae7299b64164bdce4b", + "6215458e236dd02a6407ccb4e4378deec4f724ff8014a757db254fde6e4e1661", + "6cece2785a556bda10532bb85043fb2ead2f88cb9a81b16dd9f7176fffeb631e", + "99e6d71fa35f0d54dceebbaeaabf802eca4b7bc8e3d9412bce2db1db06dea53e", + "b90ecf0215ce593784401113912cb203863ac5d420d6be436f78f6281394c61f", + "00183ab286dc8ef94cc4b1c69da36104fd65c281c3e4ec18521b3f56ad6980f7", + "db18a49e806d2bf16d915d252ec9fa049fe35805ae0621a1b675b6696d832288", + "2a255d81cf13f3c1ac14b17886ccec5d699d2dedaa837901fa796183945b5d3c", + "4ac72929cd1b9ce2a16aec54cc0a2ae803361f633241e200e2f6bd49bb127cf3", + "b7538c187aa0e70a5aa9668286e5a2a700d7d4daca599b7879836c441cb5c3dc", + "442807ca6f90ca2a85088133b64b918c0b64a435fdafa49c602e89e98fe09663", + "340fa9cf9f0b759ca8976ee3886162588011f956d49bb4dbfb10d9b257119e99", + "20915f8642170ce6d16f237377cc58d8c7fe89ada499048027d38e5727887249", + "d496cc78ad6fd17f90955f67339c24be06c378f39c2aa96f8c8e3d5bbf0296d1", + "8d65b7e4056f603c083441d1066429850960d0c7add80621feeafb851fdb000a", + "60354db88dbf4dd64f87763fbc8072e4bfb570df6bd63d6a76d5a7c4db47c311", + "79c7120470230a1e1889ab33f47f8942f642e85b24de42bb757fcff38e6b3b4b", + "8e5dcb4ca7d88c0450ebb68ed10062b00a66b93b30ceca9c2eb4546b7898fe59", + "f0a18d589b52a729de00e8b6a9b693f0b4a9ff714b0995102b0e50c983d723ea", + "f94d6e3e3a53222049d14c053ec305d7b80b309f3fe04bd5f49ca66476a6b683", + "092d723b623a5079b17013f1d053642cb95127aed02bd965ee94104f6e81597b", + "b6955bdd3b2abb204846496ebbdd730414273a331a35fa99650f2754c9e649c8", + "bf2df3e0a00f72e3653d29a5de844b46901a1aa7b26b33efc6f83408ef4cb026", + "cc148d06bc75292c3afbc42429fa3ac78438a9d7d5b2f114580844e1211f0019", + "6e621219612f0742f6d169e9b12367e9ad198173070a9e6665b8f6155bbc3508", + "00ab720386ad25a6a57ba2727de405597385328aa65acecda6abeb64005044a9", + "235a8bbca828d5e1bf0e4304766a4a5886c8b3eec0908c8c92a815392a48760b", + "72a60ba97fd512e3cc39087610a561a4adc86af8a21458a4eb3253d41500c6c7", + "d318d8cd517eb4e7cc4c167674116506e049c7c87bee526f9a916b146b6a55a5", + "512d8b1d097c1afc2676ea4ca554dee0d6090f0781882fda6fd0cbfdedb7030f", + "41ee3cd73aba19cbc35e38ebb644a4d6e8f7f234fe0a2f11f690f82b0a16679b", + "0ab4677d2c121b7b775be8a0d187eb78417375c0771ca65eba79ab6fd53d05a4", + "89874ccd8f7f18ef6a3c6f471c298cb4a7f67116151daaeb55214c99e73c92ec", + "4cd5d044a59b89f1e44d135e1ca5384ceb6f6c70d797de15e1dbbe466ec926ce", + "228ab0a4f6c94f5d0eae569996bb8f446ab7d80549e99578433057f0384bed5f", + "42ea02576d98f66bcaccef3aa885666aec304235ef95c0efcdfc1ddab5fc4b53", + "6e8fcdf387014b729e20ab5c3d6c9be70bf90c0779a8fedbd5c2b55dd8dfdc0d", + "ab5a89261beb8f94416a5c7d869e2fe2066728f1ec0f75d7f14193fcdca8dfbc", + "50fde37047d2805f0499b380d59aa21556c67117fd866faa710757e4cb773d66", + "67edb82c64a09464c8856a56b3461fc6c751fa71f614b7c9a6679be558307c86", + "4f163a7ba2e4e7334d93220e21a2865f825d3e7c143008321e4b587c5f139a5e", + "7d966efd36d7e92b0017bc79743b4007b628d0400a143ead5d4cc9478c2003c9", + "6e0bdeb594e1f1ca8eb5beaa8c6678b1ca850c472a1e127f96ec3e878029ea6b", + "9d780b5d2f421bf544f6d492aaa9ac7c9be626218d087b22b48da69ac0160173", + "7cf18c8d742b40161e1f35e8461b8891ef5335fd8581dd7026d387360e6292a7", + "d8e8a45b9d378ae74e6ab9413736ca25e887b5c3b800092d3659e4ec5cb511f7", + "0f599208fca2e75fd62ae49b624061d6e558dbf44c9376c9dcd77816c9e2922f", + "a94e3e85fc2eabbe96f4dc4afec11d3e6c48a2dbf7c3f7d9aa1568b1edff95e0", + "06b1e1d438b5ca16c78076e8dc0ceb7d8abc9bf9275909462c83b721db55e431", + "d620282696bf3e1dab3b5224515fcb68a01afce74793f55ed7ac04e437814412" + ], + "clean_local": { + "ADDs": 24248, + "COPYs": [ + [ + 471, + 510, + 0, + 7 + ], + [ + 472, + 511, + 0, + 7 + ], + [ + 473, + 512, + 0, + 7 + ], + [ + 474, + 513, + 0, + 7 + ], + [ + 475, + 514, + 0, + 7 + ], + [ + 476, + 515, + 0, + 7 + ], + [ + 477, + 516, + 0, + 7 + ], + [ + 478, + 517, + 0, + 7 + ], + [ + 479, + 518, + 0, + 7 + ] + ], + "histogram": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "mass": 5121, + "prefix": 1890 + }, + "complete_five_call_histogram": { + "1": 6613, + "2": 6710, + "3": 395, + "4": 220, + "5": 510, + "6": 55, + "7": 81 + }, + "complete_scalar_ADDs": 112095, + "executed_controls": { + "omitted_ERASE": "immutable original snapshot source", + "wrong_integer_source_code_sign_parity_unchanged": true, + "wrong_side_C_N": true + }, + "forward_dense_integer_sha256": "61efdf47b2209a550b5ef931da59bb0c85946c1ef87258a79332fd3edae84eb0", + "forward_local": { + "ADDs": 13283, + "COPYs": [ + [ + 0, + 1, + 525, + 1 + ], + [ + 1, + 1, + 526, + 1 + ], + [ + 2, + 1, + 527, + 1 + ] + ], + "histogram": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "mass": 5061, + "prefix": 64400 + }, + "inverse_local": { + "ADDs": 13283, + "COPYs": [ + [ + 2, + 1, + 527, + 1 + ], + [ + 1, + 1, + 526, + 1 + ], + [ + 0, + 1, + 525, + 1 + ] + ], + "histogram": { + "1": 1325, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 9 + }, + "mass": 5061, + "prefix": 1405988 + }, + "limits": [ + "Local signed and binary columns plus exact typed lifecycle; private register is required zero, not arbitrary dirt.", + "The universal operator-ring identity is over binary VALUES; integer scalar residuals are separately retained.", + "Helpers have logical identity and physical residual frame progress; reverse owner admission is separate.", + "Old native internal MOVE/COPY realizations, all chronological owners, rounded children, access and tape costs remain inherited or unresolved.", + "Historical million-pair searches and rolling obstructions are not replayed or included in this theorem." + ], + "literal_inverse_dense_integer_sha256": "6e177a4a0baf9f9421f9ff71b49e61e213d6e4c23c1c0fae407f4d9c9fd22e5f", + "native_rank_mass": 25545, + "no_new_kappa": true, + "nonzero_C_coefficients_covered_by_port_intertwiners": 6465, + "order_divisor_checks": [ + 7, + 73, + 511 + ], + "ordinary_arbitrary_input_columns": 660, + "ordinary_helper_progress": 17520, + "ordinary_helper_rows": 438, + "private_COPY_rank": 255, + "private_arbitrary_input_not_claimed": true, + "public_progress": 7992, + "required_zero_private_rows": 1, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_CODE_ADDs": 1487, + "source_consuming_deficit_uncredited_remnant": -669, + "source_consuming_linked_source_remnants": 111, + "source_consuming_scalar_ADDs": 16257, + "source_consuming_zero_target_fields": 111, + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/BIT-THREE-COPY-INPUT-WORD.json.gz": "ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847", + "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/MUTABLE-SOURCE-FIVE.json": "ccd6d8386223878c3a34307715ebf7236de25eeabbeaca36f9fd77d0eb1fda95", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "status": "PASS_INDEPENDENT_C511_NATIVE_INTERFACE_AND_NEGATIVE_BUDGET", + "uncovered_deficit": -33, + "universal_operator_algebra": { + "first_coded_replacement": "[[0,N],[C*N,0]] != [[0,N],[N*C,0]]", + "five_call_normalized": "diag(N*C,N)", + "physical_inverse_verified_both_orders": true, + "relations": "F central involution; N involution; C invertible; no N/C commutation or finite order used.", + "source_consuming_with_arbitrary_y": "(G*x,F*x+C^-1*G*y)" + } +} diff --git a/research/c511-mutable-source-boundary/frozen/reviews/native/independent_check.py b/research/c511-mutable-source-boundary/frozen/reviews/native/independent_check.py new file mode 100644 index 0000000000..2c597d0296 --- /dev/null +++ b/research/c511-mutable-source-boundary/frozen/reviews/native/independent_check.py @@ -0,0 +1,302 @@ +#!/usr/bin/env python3 +"""Independent dense C511 local replay, exact chart construction and operator proof. + +No producer mathematics is imported. Standard library only. Substantial +OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter,deque +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse,gzip,json + +ROOT=Path('/Users/ross/git/math') +HERE=Path(__file__).resolve().parent +OLD=ROOT/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive' +RUN=ROOT/'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller' +N,V=660,111 + +def need(ok,m): + if not ok:raise ValueError(m) + +def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':')).encode() +def ident(n):return [[int(i==j) for j in range(n)] for i in range(n)] +def mm(a,b):return [[sum(x*y for x,y in zip(r,c)) for c in zip(*b)] for r in a] +def transpose(a):return list(map(list,zip(*a))) +def bits(n):return [i for i in range(n.bit_length()) if n>>i&1] +def xor(xs): + out=0 + for x in xs:out^=x + return out +def rankq(rows): + a=[list(map(Q,r)) for r in rows];k=0 + if not a:return 0 + for j in range(len(a[0])): + p=next((p for p in range(k,len(a)) if a[p][j]),None) + if p is None:continue + a[k],a[p]=a[p],a[k];v=a[k][j];a[k]=[x/v for x in a[k]] + for p in range(k+1,len(a)): + v=a[p][j] + if v:a[p]=[x-v*y for x,y in zip(a[p],a[k])] + k+=1 + if k==len(a[0]):break + return k +def rank2(rows): + b={} + for x in rows: + while x: + p=x.bit_length()-1 + if p in b:x^=b[p] + else:b[p]=x;break + return len(b) +def binary(rows):return [sum((x%2)<0,'typed nested MOVE') + frames[d]=after;hist[f]+=1 + elif op==1: + need(0<=s<=N and s!=d and frames[d]==frames[s]==f,'typed common-frame ADD') + need(d!=live,'immutable original snapshot source') + v=-c if back else c + state[d]=[x+v*y for x,y in zip(state[d],state[s])] + peak=max(peak,sum(map(abs,state[d])));adds+=1 + elif op==(3 if back else 2): + need(live is None and s==N and state[N]==[0]*N and frames[N] is None and frames[d]==c,'fresh zero private COPY') + need(masks[f]<=masks[c] and dims[c]>dims[f],'positive nested COPY tariff') + cost=dims[c]-dims[f];hist[cost]+=1 + copies.append([d,c,f,cost]);state[N]=state[d][:];frames[N]=f;live=d + else: + need(op==(2 if back else 3) and live==d and s==N and frames[d]==c and frames[N]==f and state[N]==state[d],'literal ERASE original exact snapshot') + state[N]=[0]*N;frames[N]=None;live=None + need(frames==(program['start'] if back else program['final'])+[None] and live is None and state[N]==[0]*N,'all typed endpoints and zero private return') + return state,{'histogram':dict(hist),'mass':sum(k*v for k,v in hist.items()),'ADDs':adds,'COPYs':copies,'prefix':peak} + +def clean_program(raw,dims): + frames=raw['start'][:];records=[] + def move(d,f): + if frames[d]!=f: + records.append([0,d,frames[d],f,dims[f]-dims[frames[d]],0]);frames[d]=f + for phase,tag,sign in [('D',10,1),('A',2,1)]: + for f,d,ss in raw[phase]: + for r in [d]+ss:move(r,f) + records += [[1,d,s,sign,f,tag] for s in ss] + for j,h in enumerate(raw['ret']): + records.append([2,h,N,frames[h],0,3]) + records += [[1,V+p,N,1,0,3] for p,ss in enumerate(raw['scatter']) if j in ss] + records.append([3,h,N,frames[h],0,3]) + for phase,tag,sign in [('B',4,1),('C',5,-1)]: + for f,d,ss in raw[phase]: + for r in [d]+ss:move(r,f) + records += [[1,d,s,sign,f,tag] for s in ss] + for d,f in enumerate(raw['final']):move(d,f) + return {'start':raw['start'],'final':raw['final'],'records':records} + +def routes(raw,full): + # First choose the deterministic BFS tree on root labels, then reconstruct + # every chart from its path. This does not call physical_code.actual_routes. + roots=full['lines'];parent={0:None};queue=deque([0]) + while queue: + p=queue.popleft() + for q in range(120): + ip=sum(x*y for x,y in zip(roots[p],roots[q]))//2 + if q not in parent and abs(ip)==1: + parent[q]=(p,ip);queue.append(q) + need(len(parent)==120,'complete120-line Weyl BFS') + gs=[] + for q in range(120): + path=[];at=q + while parent[at] is not None: + p,sgn=parent[at];path.append((p,at,sgn));at=p + g=ident(8) + for p,t,sgn in reversed(path): + v=[a-sgn*b for a,b in zip(roots[p],roots[t])];den=sum(x*x for x in v) + ref=[[Q(i==j)-Q(2*v[i]*v[j],den) for j in range(8)] for i in range(8)] + g=mm(ref,g) + need(mm(transpose(g),g)==ident(8),'orthogonal exact Weyl chart') + gs.append(g) + rh=[];Ps=[];hashes=[] + H=[[Q(i==j and i<8) for j in range(15)] for i in range(15)] + E=[[Q(i==j and i>=8) for j in range(15)] for i in range(15)] + for p,q in enumerate(raw['lines']): + g=gs[raw['ports_geom'][p]];A=[row[1:] for row in g] + P=[[Q(x*y,4) for y in q] for x in q] + K=[[Q(i==j)-P[i][j] for j in range(8)] for i in range(8)] + need(mm(A,transpose(A))==K and mm(transpose(A),A)==ident(7),'actual cap isometry') + rho=[P[i]+A[i] for i in range(8)]+[row+[Q(0)]*7 for row in transpose(A)] + need(rho==transpose(rho) and mm(rho,rho)==ident(15),'exact rho involution') + oldcap=[[K[i][j] if i<8 and j<8 else Q(0) for j in range(15)] for i in range(15)] + line=[[P[i][j] if i<8 and j<8 else Q(0) for j in range(15)] for i in range(15)] + localfull=[[line[i][j]+E[i][j] for j in range(15)] for i in range(15)] + need(mm(mm(rho,oldcap),rho)==E and mm(mm(rho,localfull),rho)==H,'actual old-cap and localFULL intertwiners') + need(mm(mm(rho,line),rho)==line,'same native line under rho') + hashes.append(sha256(json.dumps([[str(x) for x in row] for row in rho],separators=(',',':')).encode()).hexdigest()) + rh.append(rho);Ps.append(line) + return rh,Ps,hashes + +# Operator monomials form C2(F) x (C2(N) * Z(C)); F commutes both N,C. +# A normal word is (F parity, alternating N marker0 and nonzero C exponents). +def normal(f,word): + out=[] + for x in word: + if out and x==out[-1]==0:out.pop() + elif out and x!=0 and out[-1]!=0: + value=out.pop()+x + if value:out.append(value) + else:out.append(x) + return (f%2,tuple(out)) +def poly(f=0,word=()):return {normal(f,word)} +def add(a,b):return a^b +def product(a,b): + out=set() + for (f,u) in a: + for (g,v) in b: + w=normal(f+g,u+v) + if w in out:out.remove(w) + else:out.add(w) + return out +def matmul(a,b):return [[add(product(a[i][0],b[0][j]),product(a[i][1],b[1][j])) for j in range(2)] for i in range(2)] +def formal(): + O=set();I=poly();F=poly(1);Nn=poly(0,(0,));C=poly(0,(1,));Ci=poly(0,(-1,));G=product(F,Nn) + identity=[[I,O],[O,I]] + physical=[[product(F,product(C,Nn)),O],[product(G,product(C,Nn)),G]] + inverse=[[product(G,Ci),O],[F,G]] + need(matmul(physical,inverse)==matmul(inverse,physical)==identity,'universal physical inverse both orders') + # Independently execute the normalized bank updates on the two input columns. + x,y=[I,O],[O,I] + def plus_left(a,k,b):return [add(u,product(k,v)) for u,v in zip(a,b)] + y=plus_left(y,Nn,x);x=plus_left(x,Nn,y);y=plus_left(y,Nn,x);x,y=y,x + need([x,y]==[[Nn,O],[O,Nn]],'three CLEAN calls and paid swap') + old=x;x=[product(product(Nn,product(C,Nn)),v) for v in old] + y=plus_left(y,product(C,Nn),old);y=plus_left(y,Nn,x) + need([x,y]==[[product(Nn,C),O],[O,Nn]],'five-call universal normal form') + Qc=[[product(Nn,product(C,Nn)),O],[product(C,Nn),I]] + Cf=[[I,O],[Nn,I]];Cb=[[I,Nn],[O,I]] + first=matmul(Cf,matmul(Cb,Qc)) + need(first==[[O,Nn],[product(C,Nn),O]] and first!=[[O,Nn],[product(Nn,C),O]],'wrong-side first-coded control') + consuming=matmul([[I,O],[O,Ci]],matmul(inverse,[[C,O],[O,I]])) + need(consuming==[[G,O],[F,product(Ci,G)]],'source-consuming map with arbitrary oldy retained') + return {'physical_inverse_verified_both_orders':True,'five_call_normalized':'diag(N*C,N)', + 'first_coded_replacement':'[[0,N],[C*N,0]] != [[0,N],[N*C,0]]', + 'source_consuming_with_arbitrary_y':'(G*x,F*x+C^-1*G*y)', + 'relations':'F central involution; N involution; C invertible; no N/C commutation or finite order used.'} + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args() + paths={'word':OLD/'BIT-THREE-COPY-INPUT-WORD.json.gz', + 'raw':ROOT/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz', + 'full':ROOT/'integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz', + 'receipt':RUN/'MUTABLE-SOURCE-FIVE.json'} + pins={k:sha256(p.read_bytes()).hexdigest() for k,p in paths.items()} + need(pins['word']=='ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847' and pins['raw']=='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022','exact frozen source pins') + word=json.loads(gzip.decompress(paths['word'].read_bytes()));raw=json.loads(gzip.decompress(paths['raw'].read_bytes()));full=json.loads(gzip.decompress(paths['full'].read_bytes()));saved=json.loads(paths['receipt'].read_text()) + need(word['public_registers']==660 and word['private_register']==660,'660 arbitrary roles and one zero private') + need(word['start']==raw['start'] and word['final']==raw['final'],'exact inherited endpoint frames') + dims=[rankq([raw['lines'][p] for p in f]) for f in raw['frames']] + forward,fw=replay(word,raw,dims);backward,bw=replay(word,raw,dims,True) + I=ident(N)+[[0]*N] + for state in (forward,backward): + need(state[2*V:N]==I[2*V:N] and state[N]==[0]*N,'all438 logical integer helpers and zero private restored') + need(all(not any(row[V:]) for row in state[:V]),'source is uncontaminated overZ') + need(all(row[V:2*V]==[int(i==j) for j in range(V)] for i,row in enumerate(state[V:2*V])),'old target exact identity block') + need(all(x%2==0 for row in state[V:2*V] for x in row[2*V:]),'integer helper leakage even') + literal=[r for r in word['records'] if r[0]==1 and r[5] in (21,22,23,24)] + need(len(literal)==1487 and all(d>= 1 + return result + + +def rank(rows): + # Low-bit pivots, deliberately distinct from the saved high-bit echelon engine. + pivots = {} + for row in rows: + while row: + bit = row & -row + if bit in pivots: + row ^= pivots[bit] + else: + pivots[bit] = row + break + return len(pivots) + + +def routes(raw, full, pin): + roots = full['lines'] + maps = {0: eye(8)} + queue = deque([0]) + while queue: + parent = queue.popleft() + for child, root in enumerate(roots): + dot = sum(x * y for x, y in zip(roots[parent], root)) + if child in maps or abs(dot) != 2: + continue + sign = 1 if dot == 2 else -1 + d = [Q(x - sign * y) for x, y in zip(roots[parent], root)] + norm = sum(x * x for x in d) + # Rank-one Householder update, without the producer's dense reflection product. + projection = [sum(d[k] * maps[parent][k][j] for k in range(8)) for j in range(8)] + maps[child] = [[maps[parent][i][j] - 2 * d[i] * projection[j] / norm + for j in range(8)] for i in range(8)] + queue.append(child) + need(len(maps) == 120, 'all upstream BFS root routes') + rhos, projectors, hashes = [], [], [] + for p, label in enumerate(raw['ports_geom']): + g = maps[label] + q = raw['lines'][p] + proj = [[Q(x * y, 4) for y in q] for x in q] + a = [row[1:] for row in g] + rho = [proj[i] + a[i] for i in range(8)] + rho += [[a[i][j] for i in range(8)] + [Q(0)] * 7 for j in range(7)] + h = digest([[str(x) for x in row] for row in rho]) + need(h == pin['actual_native_geometry']['ports'][p]['rho_sha256'], 'actual rho exact bytes') + need(matmul(rho, rho) == eye(15), 'actual rho involution') + rhos.append(rho) + projectors.append(proj) + hashes.append(h) + return rhos, projectors, hashes + + +# Free noncommutative polynomials; only adjacent N*N is reduced. +def multiply(a, b): + answer = set() + for x in a: + for y in b: + word = [] + for letter in x + y: + if letter == 'N' and word and word[-1] == 'N': + word.pop() + else: + word.append(letter) + word = tuple(word) + answer.symmetric_difference_update({word}) + return frozenset(answer) + + +def multiply_blocks(a, b): + return [[multiply(a[i][0], b[0][j]) ^ multiply(a[i][1], b[1][j]) + for j in range(2)] for i in range(2)] + + +def formal_residual(saved): + one, zero = frozenset({()}), frozenset() + n = frozenset({('N',)}) + c = [frozenset({('C' + str(j),)}) for j in range(3)] + lower = lambda j: [[one, zero], [multiply(n, c[j]), one]] + upper = [[one, multiply(n, c[1])], [zero, one]] + result = multiply_blocks(lower(2), multiply_blocks(upper, lower(0))) + a1 = multiply(n, multiply(c[1], n)) + a2 = multiply(n, multiply(c[2], n)) + expected = [[one ^ multiply(a1, c[0]), multiply(n, c[1])], + [multiply(n, c[2] ^ multiply(c[2], multiply(a1, c[0])) ^ c[0]), + one ^ multiply(a2, c[1])]] + need(result == expected, 'free noncommutative three-call expansion') + phi = multiply(n, result[0][0]) + need(phi == n ^ multiply(c[1], multiply(n, c[0])), 'Phi=N+C1*N*C0') + token = {0: 'N', 1: 'C0', 511: 'C1', 1021: 'C2'} + decoded = [[frozenset(tuple(token[x] for x in word) for word in item) + for item in row] for row in saved['normalized_three_call_residual']] + need(result == decoded, 'all saved residual coefficients') + return [[sorted(map(list, entry)) for entry in row] for row in result] + + +def main(): + pins = { + RAW: 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022', + FULL: '1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55', + CODE: 'ac8a6dcd5957f49eefd6fc945332b1c31afa26c48fc301d37bfb1338beea6847', + PIN: 'ccd6d8386223878c3a34307715ebf7236de25eeabbeaca36f9fd77d0eb1fda95'} + sources = {str(p): sha256(p.read_bytes()).hexdigest() for p in (*pins, BOUNDARY, QUOTIENT)} + for p, expected in pins.items(): + need(sources[str(p)] == expected, 'exact scientific input ' + p.name) + raw = json.loads(gzip.decompress(RAW.read_bytes())) + full = json.loads(gzip.decompress(FULL.read_bytes())) + program = json.loads(gzip.decompress(CODE.read_bytes())) + pin, boundary, quotient = [json.loads(p.read_bytes()) for p in (PIN, BOUNDARY, QUOTIENT)] + instructions = [r for r in program['records'] if r[0] == 1 and r[-1] in (21, 22, 23, 24)] + need(len(instructions) == 1487, 'source code literal ADD count') + need(all(d < 111 and s < 111 and f == 1 for _, d, s, coef, f, phase in instructions), 'literal code domain') + # Execute each input column separately, then transpose back to comparison rows. + C = [0] * 111 + for source in range(111): + column = [int(i == source) for i in range(111)] + for _, dst, src, coef, frame, phase in instructions: + column[dst] ^= (coef % 2) * column[src] + for dst, bit in enumerate(column): + C[dst] |= bit << source + identity = [1 << i for i in range(111)] + need(C == pin['C_binary_rows'] and rank(C) == 111, 'actual C511 rows') + need(rank([x ^ y for x, y in zip(C, identity)]) == 9, 'scalar C-I rank9') + need(binary_power(C, 511) == identity and binary_power(C, 7) != identity + and binary_power(C, 73) != identity, 'exact order511') + rhos, projectors, rho_hashes = routes(raw, full, pin) + r, P = list(map(modular, rhos)), list(map(modular, projectors)) + formal = formal_residual(boundary) + columns = [[dst for dst in range(111) if C[dst] >> source & 1] for source in range(111)] + records, sample_summaries, original_rows = [], [], [] + all_maps = [] + identity_checks = 0 + first_boundary = None + for j in range(8): + v = tuple(int(i == j) for i in range(15)) + direct = [] + intermediate = [] + for k in range(111): + tail = mv(P[k], v[:8]) + (0,) * 7 + head = tuple((x - y) % 101 for x, y in zip(v, tail)) + direct.append(head + tail) + intermediate.append((mv(r[k], head), mv(r[k], tail))) + hh, tt = intermediate[-1] + need(mv(r[k], hh) + mv(r[k], tt) == direct[-1], 'identity-code Phi cancellation') + identity_checks += 1 + # Construct each elementary input column, using C's column adjacency. + # Route addresses once per (middle port,destination), then XOR that + # path independently for each entering input coefficient. + routed = {} + for middle in range(111): + hh, tt = intermediate[middle] + for dst in columns[middle]: + routed[middle, dst] = mv(r[dst], hh) + mv(r[dst], tt) + maps = [dict() for _ in range(111)] + for source in range(111): + maps[source][direct[source]] = maps[source].get(direct[source], 0) ^ (1 << source) + for middle in columns[source]: + for dst in columns[middle]: + at = routed[middle, dst] + maps[dst][at] = maps[dst].get(at, 0) ^ (1 << source) + all_maps.append(maps) + count, support = 0, 0 + for dst, values in enumerate(maps): + for at, row in sorted(values.items()): + if row and any(at[15:]): + records.append([j, dst, list(at), row]) + original_rows.append(row) + count += 1 + support |= row + sample_summaries.append({'input_HEAD_basis': j, 'nonfree_coefficient_rows': count, + 'nonzero_SOURCE_columns': support.bit_count(), + 'accumulated_rank': rank(original_rows)}) + if j == 0: + outputs = [[list(at) for at, row in sorted(values.items()) if row & 1] for values in maps] + bad = [(dst, at) for dst, values in enumerate(outputs) for at in values if any(at[15:])] + first_boundary = {'outputs': sum(map(len, outputs)), 'nonzero_tail_outputs': len(bad), + 'digest': digest(outputs), 'first': [bad[0][0], bad[0][1]]} + need(sample_summaries == quotient['per_sample'], 'every exact sample summary') + need(len(records) == quotient['all_nonzero_coefficient_rows'] == 24898, 'complete row count') + need(digest(records) == quotient['complete_coefficient_rows_sha256'], 'complete coefficient-row digest') + need(rank(original_rows) == 111, 'independent full observation rank') + original_witnesses = [] + reduced_witnesses = [] + for cert in quotient['row_echelon_certificate']: + w = cert['original_row_witness'] + at = tuple(w['output_HEAD'] + w['output_TAIL']) + row = all_maps[w['input_HEAD_basis']][w['output_port']].get(at, 0) + need(row == w['coefficient_SOURCE_row'] and row and any(at[15:]), 'exact saved witness row') + original_witnesses.append(row) + reduced_witnesses.append(cert['reduced_row']) + need(cert['reduced_row'].bit_length() - 1 == cert['pivot'], 'saved pivot') + need(len(original_witnesses) == rank(original_witnesses) == rank(reduced_witnesses) == 111, + 'all111 saved original rows independently span the source') + old_impulse = boundary['actual_raw_word_control'] + need(first_boundary['outputs'] == old_impulse['nonzero_output_impulses'] == 3131, + 'source port0 head e0 impulse output count') + need(first_boundary['digest'] == old_impulse['complete_output_sha256'] and first_boundary['nonzero_tail_outputs'] == 1, + 'complete original impulse and unique nonfree output') + need(first_boundary['first'] == [0, [0]*15 + [1] + [0]*14], 'actual destructive tail witness') + boundary_at = tuple([0]*15 + [1] + [0]*14) + boundary_row = all_maps[0][0][boundary_at] + without_n_row = boundary_row ^ 1 + need(boundary_row & 1 and not (without_n_row & 1), 'omitting N flips actual nonfree impulse coefficient') + + # Actual code mutation: toggle C0[0,1], holding C1 and every route fixed. + # Its difference is precisely C1*N applied to middle-port0's delta. + need(C[0] >> 1 & 1, 'actual coefficient being removed') + j = 0 + tail = mv(P[0], (1,) + (0,)*7) + (0,)*7 + head = tuple((int(i == 0) - tail[i]) % 101 for i in range(15)) + hh, tt = mv(r[0], head), mv(r[0], tail) + mutated = [{at: row for at, row in values.items()} for values in all_maps[0]] + mutation_witness = None + for dst in columns[0]: + at = mv(r[dst], hh) + mv(r[dst], tt) + before = mutated[dst].get(at, 0) + mutated[dst][at] = before ^ 2 + if any(at[15:]) and mutation_witness is None: + mutation_witness = {'output_port': dst, 'ADDRESS': list(at), + 'old_source_coefficient_row': before, 'new_source_coefficient_row': before ^ 2} + need(mutation_witness is not None, 'actual code mutation changes projected observation') + mutated_records = [[0, dst, list(at), row] for dst, values in enumerate(mutated) + for at, row in sorted(values.items()) if row and any(at[15:])] + original_first = [row for row in records if row[0] == 0] + need(digest(mutated_records) != digest(original_first), 'actual mutation changes full sampled coefficient digest') + + # A rational routed coefficient proves noncommutation with N independently. + p, q = 0, 1 + need(C[p] >> q & 1, 'noncommuting coefficient present') + route = matmul(rhos[p], rhos[q]) + def padded(proj): + return [[proj[i][j] if i < 8 and j < 8 else Q(0) for j in range(15)] for i in range(15)] + left, right = matmul(padded(projectors[p]), route), matmul(route, padded(projectors[q])) + comm = next((i, j, left[i][j], right[i][j]) for i in range(15) for j in range(15) + if left[i][j] != right[i][j]) + result = {'status': 'PASS_INDEPENDENT_B09_ACTUAL_OBSERVATION_RANK111', + 'scientific_pin': '20ecf2891d80b5acf18d980b2164fb44ea7faa90', 'source_sha256': sources, + 'VALUE_coefficient_field': 'F2', 'ADDRESS_field': 101, 'C_order': 511, + 'source_code_ADDs': 1487, 'C_rank': 111, 'C_minus_I_rank': 9, + 'actual_rho_count': len(rhos), 'actual_rho_hashes': rho_hashes, + 'formal_three_call_residual': formal, 'impulse': first_boundary, + 'per_sample': sample_summaries, 'complete_coefficient_rows': len(records), + 'complete_coefficient_rows_sha256': digest(records), 'observation_rank': 111, + 'saved_original_witnesses_checked': len(original_witnesses), + 'saved_original_witness_rank': rank(original_witnesses), + 'identity_code_cancellations': identity_checks, + 'actual_C0_bit_mutation_witness': mutation_witness, + 'mutated_sample0_coefficient_digest': digest(mutated_records), + 'omitted_N_control': {'output_port': 0, 'ADDRESS': list(boundary_at), + 'source0_coefficient_before': boundary_row & 1, + 'source0_coefficient_after': without_n_row & 1}, + 'noncommuting_routed_coefficient': {'edge': [p,q], 'entry': list(comm[:2]), + 'left': str(comm[2]), 'right': str(comm[3])}, + 'scope': 'At least111 ADDRESS-independent common scalar source rows modulo tail-zero-preserving free maps; no native tariff or routed-reader bound.'} + (HERE/'INDEPENDENT-RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + print(result['status']) + print('3131 impulse outputs;24898 coefficient rows;111 witnessed independent rows;888 identity-code cancellations; actual code mutation changes output') + + +if __name__ == '__main__': + main() diff --git a/research/c511-mutable-source-boundary/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz b/research/c511-mutable-source-boundary/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz new file mode 100644 index 0000000000..e12a566658 Binary files /dev/null and b/research/c511-mutable-source-boundary/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz differ diff --git a/research/c511-mutable-source-boundary/frozen/upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz b/research/c511-mutable-source-boundary/frozen/upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz new file mode 100644 index 0000000000..8bec1751f7 Binary files /dev/null and b/research/c511-mutable-source-boundary/frozen/upstream/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz differ diff --git a/research/c511-mutable-source-boundary/verify.py b/research/c511-mutable-source-boundary/verify.py new file mode 100644 index 0000000000..f54debb1f5 --- /dev/null +++ b/research/c511-mutable-source-boundary/verify.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python3 +"""Replay exact frozen proofs with explicit path and receipt adapters only.""" +import argparse +import hashlib +import importlib.machinery +import importlib.util +import json +from pathlib import Path +import sys + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) + + +class Portable: + def __init__(self, root): + self.root = Path(root).resolve() + self.hashes = json.loads((self.root / 'FROZEN-SHA256.json').read_text()) + self.patches = json.loads((self.root / 'ADAPTATIONS.json').read_text()) + self.executed = set() + self.compared = set() + old = '/Users/ross/git/math/' + self.prefixes = { + old + 'integer-mult-bounds/': self.root / 'frozen/upstream', + old + '.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/': self.root / 'frozen/changed', + old + '.research-automation/runs/kappa-major-20261018T1330Z/': self.root / 'frozen/major', + old + '.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/': self.root / 'frozen/old', + } + + def authenticate(self, path): + path = Path(path).resolve() + name = path.relative_to(self.root).as_posix() + need(name in self.hashes, 'unregistered frozen input: ' + name) + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == self.hashes[name], 'frozen input changed: ' + name) + return raw + + def adapted(self, path): + name = Path(path).resolve().relative_to(self.root).as_posix() + source = self.authenticate(path).decode() + for edit in self.patches.get(name, []): + need(source.count(edit['old']) == 1, 'adaptation no longer unique: ' + name) + source = source.replace(edit['old'], edit['new']) + return source + + def check_all(self): + need(set(self.patches) <= set(self.hashes), 'unbound adaptation') + for name in self.hashes: + self.authenticate(self.root / name) + for name in self.patches: + self.adapted(self.root / name) + + def code(self, path): + path = Path(path).resolve() + source = self.adapted(path) + self.executed.add(path.relative_to(self.root).as_posix()) + return compile(source, str(path), 'exec', dont_inherit=True, optimize=0) + + def normalize(self, value): + if isinstance(value, str): + for prefix, target in self.prefixes.items(): + if value.startswith(prefix): + return str(target / value[len(prefix):]) + return value + if isinstance(value, dict): + result = {} + for key, item in value.items(): + normalized_key = self.normalize(key) + need(normalized_key not in result, 'normalized key collision') + result[normalized_key] = self.normalize(item) + return result + if isinstance(value, list): + return [self.normalize(v) for v in value] + return value + + def equal(self, path, value): + path = Path(path).resolve() + expected = json.loads(self.authenticate(path)) + actual = json.loads(json.dumps(value)) + # Compare every field, preserving JSON scalar types. Only original + # absolute provenance paths are mapped into this relocated package. + need(canonical(self.normalize(actual)) == canonical(self.normalize(expected)), + 'receipt mismatch: ' + path.name) + self.compared.add(path.relative_to(self.root).as_posix()) + return True + + def install(self): + portable = self + original_code = importlib.machinery.SourceFileLoader.get_code + original_exec = importlib.machinery.SourceFileLoader.exec_module + + def frozen(loader): + return Path(loader.path).resolve().is_relative_to(portable.root / 'frozen') + + def get_code(loader, fullname): + if frozen(loader): + return portable.code(loader.path) + return original_code(loader, fullname) + + def exec_module(loader, module): + if frozen(loader): + module.PORTABLE = portable + return original_exec(loader, module) + + importlib.machinery.SourceFileLoader.get_code = get_code + importlib.machinery.SourceFileLoader.exec_module = exec_module + sys.path.insert(0, str(self.root / 'frozen/changed/bit-native-caller')) + + def load(self, path): + spec = importlib.util.spec_from_file_location('portable_stage', self.root / path) + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +STAGES = { + 'interface': ('frozen/changed/bit-native-caller/mutable_source_caller.py', ['frozen/changed/bit-native-caller/MUTABLE-SOURCE-FIVE.json']), + 'rolling': ('frozen/changed/bit-native-caller/mutable_rolling_quotient.py', ['frozen/changed/bit-native-caller/MUTABLE-ROLLING-BOUNDARY.json', 'frozen/changed/bit-native-caller/MUTABLE-ROLLING-QUOTIENT.json']), + 'independent-native': ('frozen/reviews/native/independent_check.py', ['frozen/reviews/native/RESULT.json']), + 'independent-observation': ('frozen/reviews/observation/independent_check.py', ['frozen/reviews/observation/INDEPENDENT-RESULT.json']), +} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--stage', choices=STAGES, required=True) + args = parser.parse_args() + portable = Portable(Path(__file__).resolve().parent) + portable.check_all() + portable.install() + source, receipts = STAGES[args.stage] + sys.argv = [str(portable.root / source)] + module = portable.load(source) + if args.stage.startswith('independent-'): + module.main() + else: + module.receipt(False) + need(portable.compared == set(receipts), 'incomplete receipt coverage') + portable.check_all() + print(canonical({'status': 'PASS_C511_MUTABLE_SOURCE_BOUNDARIES', 'stage': args.stage, + 'receipts': sorted(portable.compared), 'sources': sorted(portable.executed), + 'no_new_kappa': True})) + + +if __name__ == '__main__': + main()